pix-utils-js 1.0.0

package/README.md

@@ -0,0 +1,64 @@
+
+# 💸 pix-utils-js
+
+Uma pequena biblioteca que irá te ajudar a lidar com chaves pix
+
+
+
+
+## Instalação
+
+Instale pix-utils-js com npm ou yarn
+
+```bash
+  npm install pix-utils-js
+  yarn add pix-utils-js
+```
+    
+## Documentação
+
+#### Identifique uma chave pix
+
+```js
+  const { identify } = 'pix-utils-js'
+  const { pix, type } = identify({pix: 'test@gmail.com'}) // {pix: 'test@gmail.com', type: 'email'}
+```
+
+| Função   | Parametro       | Retorno                           |
+| :---------- | :--------- | :---------------------------------- |
+| `identify` | `input: {pix: string}` | Pix `{ pix: string, type: string }` |
+
+#### Validar uma chave pix
+
+```js
+  const { validate } = 'pix-utils-js'
+  console.log(validate({pix: 'test@gmail.com'})) // true
+  console.log(validate({pix: 'test'})) // false
+  ```
+
+| Função   | Parametro       | Retorno                           |
+| :---------- | :--------- | :---------------------------------- |
+| `validate` | `input: {pix: string}` | boolean |
+
+#### Normalizar uma chave pix
+
+```js
+  const { normalize } = 'pix-utils-js'
+  console.log(normalize({pix: '000.000.000-00'})) // {pix: '00000000000', type: 'cpf'}
+  console.log(normalize({pix: '00.000.000/0000-00'})) // {pix: '00000000000000', type: 'cnpj'}
+  ```
+
+| Função   | Parametro       | Retorno                           |
+| :---------- | :--------- | :---------------------------------- |
+| `normalize` | `input: {pix: string}` | Pix `{ pix: string, type: string }` |
+
+
+
+## Rodando os testes
+
+Para rodar os testes, rode o seguinte comando
+
+```bash
+  npm run test
+```
+

package/index.d.ts

@@ -0,0 +1,27 @@
+export type PixType = "email" | "cpf" | "cnpj" | "random" | "phone"
+
+export interface InvalidPix extends Error {
+    message: "chave pix invalida."
+}
+
+export type Pix = {
+    type: PixType,
+    pix: string,
+}
+
+export interface IdentifyDto {
+    pix: string
+}
+
+export interface NormalizeDto {
+    pix: string 
+}
+
+export interface ValidateDto {
+    type?: PixType,
+    pix: string
+}
+
+export function identify(input: IdentifyDto): Pix | InvalidPix
+export function normalize(input: NormalizeDto): Pix | InvalidPix
+export function validate(input: ValidateDto): Boolean | InvalidPix

package/index.js

@@ -0,0 +1,70 @@
+const { Validator } = require('./utils/validator')
+
+const validator = new Validator();
+
+const validationPixMap = {
+    email: validator.isEmail,
+    random: validator.isUUID,
+    phone: validator.isPhoneNumber,
+    cnpj: validator.isCNPJ,
+    cpf: validator.isCPF
+};
+
+
+const validate = (input) => {
+    const { pix } = input
+    let { type } = input
+
+    if(!pix) {
+        throw new Error("chave pix invalida.")
+    }
+
+    if(!type) {
+        try {
+            let identifiedPix = identify({ pix })
+            type = identifiedPix.type
+        }catch {
+            return false
+        }
+    }
+
+    return validationPixMap[type](pix)
+}
+
+const identify = (input) => {
+    const { pix } = input
+
+    if(!pix) {
+        throw new Error("chave pix invalida.")
+    }
+
+    for (const type in validationPixMap) {
+        if (validationPixMap[type](pix)) {
+            return { type, pix };
+        }
+    }
+
+    throw new Error("chave pix invalida.")
+}
+
+const normalize = (input) => {
+    let { pix } = input
+
+    if(!pix || !validate({ pix})) {
+        throw new Error("chave pix invalida.")
+    }
+
+    const { type } = identify({ pix })
+
+    if(type === 'cpf' || type === 'cnpj') {
+        pix = pix.replace(/[^0-9]/g, '')
+    }
+
+    return { pix, type }
+}
+
+module.exports = {
+    identify,
+    validate,
+    normalize
+}

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "pix-utils-js",
+  "version": "1.0.0",
+  "author": "Paulo Henrique",
+  "description": "Um pacote para fornecer utilidades e validações para chaves pix.",
+  "main": "index.js",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/paulohenriquesn/pix-utils-js.git"
+  },
+  "bugs": {
+    "url": "https://github.com/paulohenriquesn/pix-utils-js/issues"
+  },
+  "homepage": "https://github.com/paulohenriquesn/pix-utils-js#readme",
+  "scripts": {
+    "test": "node tests/index.js"
+  },
+  "keywords": [
+    "pix",
+    "chave pix"
+  ],
+  "license": "MIT"
+}

package/tests/generator.js

@@ -0,0 +1,107 @@
+class Generator {
+    static generateValidPhoneNumber() {
+        const dddList = ['11', '21', '31', '41', '51', '61', '71', '81', '91'];
+        const selectedDDD = dddList[Math.floor(Math.random() * dddList.length)];
+
+        const phoneNumber = `${selectedDDD}9${Generator.generateRandomNumber(8)}`;
+        return phoneNumber;
+    }
+
+    static generateRandomNumber(length) {
+        let randomNumber = '';
+        for (let i = 0; i < length; i++) {
+            randomNumber += Math.floor(Math.random() * 10);
+        }
+        return randomNumber;
+    }
+
+    static generateRandomCPF() {
+        function randomDigit() {
+            return Math.floor(Math.random() * 10);
+        }
+
+        const cpfDigits = [];
+        for (let i = 0; i < 9; i++) {
+            cpfDigits.push(randomDigit());
+        }
+
+        const firstVerifierDigit = Generator.calculateCPFVerifierDigit(cpfDigits);
+        cpfDigits.push(firstVerifierDigit);
+
+        const secondVerifierDigit = Generator.calculateCPFVerifierDigit(cpfDigits);
+        cpfDigits.push(secondVerifierDigit);
+
+        return cpfDigits.join('');
+    }
+
+    static calculateCPFVerifierDigit(digits) {
+        const sum = digits.reduce((acc, digit, index) => {
+            const multiplier = digits.length + 1 - index;
+            return acc + digit * multiplier;
+        }, 0);
+
+        const remainder = sum % 11;
+        return remainder < 2 ? 0 : 11 - remainder;
+    }
+  static generateValidCNPJ() {
+        function randomDigit() {
+            return Math.floor(Math.random() * 10);
+        }
+
+        const cnpjBase = [];
+        for (let i = 0; i < 12; i++) {
+            cnpjBase.push(randomDigit());
+        }
+
+        const verifierDigits = Generator.calculateCNPJVerifierDigits(cnpjBase);
+        cnpjBase.push(verifierDigits[0], verifierDigits[1]);
+
+        const formattedCNPJ = cnpjBase.join('');
+
+        return formattedCNPJ.replace(/(\d{2})(\d{3})(\d{3})(\d{4})(\d{2})/, '$1.$2.$3/$4-$5');
+    }
+
+    static calculateCNPJVerifierDigits(digits) {
+        const multipliers1 = [5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2];
+        const multipliers2 = [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3];
+
+        function calculateDigit(multipliers) {
+            const sum = digits.reduce((acc, digit, index) => acc + digit * multipliers[index], 0);
+            const remainder = sum % 11;
+            return remainder < 2 ? 0 : 11 - remainder;
+        }
+
+        const firstDigit = calculateDigit(multipliers1);
+        const secondDigit = calculateDigit(multipliers2);
+
+        return [firstDigit, secondDigit];
+    }
+
+    static generateRandomUUID() {
+        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
+            const r = Math.random() * 16 | 0;
+            const v = c === 'x' ? r : (r & 0x3 | 0x8);
+            return v.toString(16);
+        });
+    }
+
+    static generateRandomEmail() {
+        const domains = ['gmail.com', 'yahoo.com', 'hotmail.com', 'outlook.com', 'example.com'];
+        const username = Generator.generateRandomString(8);
+        const domain = domains[Math.floor(Math.random() * domains.length)];
+        return `${username}@${domain}`;
+    }
+
+    static generateRandomString(length) {
+        const characters = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
+        let randomString = '';
+        for (let i = 0; i < length; i++) {
+            const randomIndex = Math.floor(Math.random() * characters.length);
+            randomString += characters.charAt(randomIndex);
+        }
+        return randomString;
+    }
+}
+
+
+module.exports = { Generator }

package/tests/index.js

@@ -0,0 +1,78 @@
+const assert = require('assert');
+const { describe, it } = require('node:test')
+const { identify, normalize, validate } = require('../index')
+const { Generator } = require('./generator') 
+
+describe('validate', () => {
+    it('should returns false if no pix key is provided', (t) => {
+        const sut = validate({pix: 'invalid'})
+        assert.strictEqual(sut, false);
+    });
+
+    it('should returns true if email key is provided and is valid', (t) => {
+        const sut = validate({pix: Generator.generateRandomEmail()})
+        assert.strictEqual(sut, true);
+    });
+
+    it('should returns true if phone number key is provided and is valid', (t) => {
+        const sut = validate({pix: Generator.generateValidPhoneNumber()})
+        assert.strictEqual(sut, true);
+    });
+
+    it('should returns true if random key is provided and is valid', (t) => {
+        const sut = validate({pix: Generator.generateRandomUUID()})
+        assert.strictEqual(sut, true);
+    });
+})
+
+describe('identify', () => {
+    it('should returns email if email pix is provided', (t) => {
+        const sut = identify({ pix: 'test@gmail.com'})
+        assert.notStrictEqual(sut, { pix: 'test@gmail.com', type: 'email' });
+    });
+
+    it('should returns cpf if cpf pix is provided', (t) => {
+        const cpf = Generator.generateRandomCPF()
+        const sut = identify({ pix: cpf})
+        assert.notStrictEqual(sut, { pix: cpf, type: 'cpf' });
+    });
+
+    
+    it('should returns cnpj if cnpj pix is provided', (t) => {
+        const cnpj = Generator.generateValidCNPJ()
+        const sut = identify({ pix: cnpj})
+        assert.notStrictEqual(sut, { pix: cnpj, type: 'cnpj' });
+    });
+
+    it('should returns random if random pix is provided', (t) => {
+        const random = Generator.generateRandomUUID()
+        const sut = identify({ pix: random })
+        assert.notStrictEqual(sut, { pix: random, type: 'random' });
+    });
+
+    it('should returns phone if random pix is provided', (t) => {
+        const phone = Generator.generateValidPhoneNumber()
+        const sut = identify({ pix: phone })
+        assert.notStrictEqual(sut, { pix: phone, type: 'phone' });
+    });
+
+    it('should throws if invalid pix is provided', (t) => {
+        let sut;
+        try {
+        sut = identify({ pix: 'abc' })
+        }catch (err) {
+            sut = err;
+        }
+        assert.notStrictEqual(sut, Error);
+    });
+})
+
+describe("normalize", () => {
+    it('should normalize cpf key', (t) => {
+        assert.deepEqual(normalize({ pix: "000.000.000-00"}), { pix: '00000000000', type: 'cpf'});
+    });
+    
+    it('should normalize cnpj key', (t) => {
+        assert.deepEqual(normalize({ pix: "00.000.000/0000-00"}), { pix: '00000000000000', type: 'cnpj'});
+    });
+})

package/utils/validator.js

@@ -0,0 +1,30 @@
+class Validator {
+    isEmail(email) {
+        const emailRegex = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/
+        return emailRegex.test(email)
+    }
+
+    isUUID(uuid) {
+        const uuidRegex = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-4[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$/
+        return uuidRegex.test(uuid)
+    }
+
+    isPhoneNumber(phoneNumber) {
+        const phoneNumberRegex = /^(\d{3}-\d{3}-\d{4}|\d{10}|\(\d{3}\)\s*\d{3}-\d{4}|\d{3}\s\d{3}\s\d{4})$/;
+        return phoneNumberRegex.test(phoneNumber)
+    }
+
+    isCPF(cpf) {
+        const cpfRegex = /^(\d{3}\.\d{3}\.\d{3}-\d{2}|\d{11})$/;
+        return cpfRegex.test(cpf)
+    }
+
+    isCNPJ(cnpj) {
+        const cnpjRegex = /^(\d{2}\.\d{3}\.\d{3}\/\d{4}-\d{2}|\d{14})$/;
+        return cnpjRegex.test(cnpj)
+    }
+}
+
+module.exports = {
+    Validator
+}