@btffamily/vacepey 1.0.1

package/build/utils/snippets/decryption.snippet.js

@@ -0,0 +1,255 @@
+"use strict";
+//** PYTHON DECRYPT for 'encryptAESGCM' function  */
+// from Crypto.Cipher import AES
+// from Crypto.Util.Padding import unpad
+// from Crypto.Protocol.KDF import PBKDF2
+// from Crypto.Hash import SHA256
+// import binascii
+// # You must change this to match your Node.js key derivation function, salt, and iterations.
+// # This is a crucial step!
+// def derive_key(password: str, salt: bytes):
+//     # Example: PBKDF2 with SHA256, a fixed salt, and 100000 iterations
+//     return PBKDF2(password, salt, dkLen=32, count=100000, hmac_hash_module=SHA256)
+// def decrypt_aes_cbc(encrypted_hex: str, iv_hex: str, password: str):
+//     try:
+//         # 1. Decode hex strings to bytes
+//         encrypted_bytes = binascii.unhexlify(encrypted_hex)
+//         iv_bytes = binascii.unhexlify(iv_hex)
+//         # A placeholder salt. You need to use the same salt as your Node.js code.
+//         salt = b'\x00' * 16
+//         # 2. Derive the key using the same function as Node.js
+//         key = derive_key(password, salt)
+//         # 3. Create the AES cipher object with CBC mode
+//         cipher = AES.new(key, AES.MODE_CBC, iv=iv_bytes)
+//         # 4. Decrypt the data and remove the padding
+//         decrypted_bytes = cipher.decrypt(encrypted_bytes)
+//         # Unpad the decrypted data (assumes PKCS7 padding)
+//         unpadded_bytes = unpad(decrypted_bytes, AES.block_size)
+//         return unpadded_bytes.decode('utf-8')
+//     except Exception as e:
+//         print(f"Decryption failed: {e}")
+//         return None
+// if __name__ == '__main__':
+//     # Replace these with actual values from your Node.js encryption
+//     encrypted_data = "your_encrypted_hex_string"
+//     iv_string = "your_iv_hex_string"
+//     password = "your_password"
+//     decrypted_text = decrypt_aes_cbc(encrypted_data, iv_string, password)
+//     if decrypted_text:
+//         print("Decrypted Data:", decrypted_text)
+// >> ================================================================================================
+//** GOLANG DECRYPT for 'encryptAESGCM' function  */
+// package main
+// import (
+//     "bytes"
+//     "crypto/aes"
+//     "crypto/cipher"
+//     "crypto/rand"
+//     "crypto/sha256"
+//     "encoding/hex"
+//     "fmt"
+//     "io"
+//     "log"
+//     "golang.org/x/crypto/pbkdf2"
+// )
+// // You must change this to match your Node.js key derivation function, salt, and iterations.
+// // This is a crucial step!
+// func deriveKey(password string, salt []byte) []byte {
+//     // Example: PBKDF2 with a fixed salt and 100000 iterations
+//     return pbkdf2.Key([]byte(password), salt, 100000, 32, sha256.New)
+// }
+// // pkcs7Unpad removes PKCS7 padding from the data.
+// func pkcs7Unpad(data []byte) ([]byte, error) {
+//     if len(data) == 0 {
+//         return nil, fmt.Errorf("pkcs7: data is empty")
+//     }
+//     padSize := int(data[len(data)-1])
+//     if padSize > len(data) {
+//         return nil, fmt.Errorf("pkcs7: invalid padding size")
+//     }
+//     return data[:len(data)-padSize], nil
+// }
+// func decryptAESCBC(encryptedHex string, ivHex string, password string) (string, error) {
+//     // 1. Decode hex strings to byte slices
+//     encrypted, err := hex.DecodeString(encryptedHex)
+//     if err != nil {
+//         return "", fmt.Errorf("could not decode encrypted data: %w", err)
+//     }
+//     iv, err := hex.DecodeString(ivHex)
+//     if err != nil {
+//         return "", fmt.Errorf("could not decode IV: %w", err)
+//     }
+//     // A placeholder salt. You need to use the same salt as your Node.js code.
+//     salt := make([]byte, 16) 
+//     if _, err := io.ReadFull(rand.Reader, salt); err != nil {
+//         log.Fatal(err)
+//     }
+//     // 2. Derive the key using the same function as Node.js
+//     key := deriveKey(password, salt)
+//     // 3. Create a new AES cipher block
+//     block, err := aes.NewCipher(key)
+//     if err != nil {
+//         return "", fmt.Errorf("could not create AES cipher: %w", err)
+//     }
+//     // 4. Create a new CBC decrypter
+//     mode := cipher.NewCBCDecrypter(block, iv)
+//     // 5. Decrypt the data
+//     decrypted := make([]byte, len(encrypted))
+//     mode.CryptBlocks(decrypted, encrypted)
+//     // 6. Remove the padding
+//     unpadded, err := pkcs7Unpad(decrypted)
+//     if err != nil {
+//         return "", fmt.Errorf("could not remove padding: %w", err)
+//     }
+//     return string(unpadded), nil
+// }
+// func main() {
+//     // Replace these with actual values from your Node.js encryption
+//     encryptedData := "your_encrypted_hex_string"
+//     ivString := "your_iv_hex_string"
+//     password := "your_password"
+//     decryptedText, err := decryptAESCBC(encryptedData, ivString, password)
+//     if err != nil {
+//         log.Fatalf("Decryption failed: %v", err)
+//     }
+//     fmt.Println("Decrypted Data:", decryptedText)
+// }
+// >> ================================================================================================
+//** PYTHON DECRYPT FOR 'encryptAESGCM2' function */
+// # decrypt.py
+// import base64
+// from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
+// from cryptography.hazmat.primitives import hashes
+// from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
+// from cryptography.hazmat.backends import default_backend
+// def decrypt(data: dict) -> str:
+//     """
+//     Decrypts an AES-256-GCM encrypted data dictionary.
+//     """
+//     try:
+//         salt = base64.b64decode(data['salt'])
+//         iv = base64.b64decode(data['vector'])
+//         auth_tag = base64.b64decode(data['authTag'])
+//         ciphertext = base64.b64decode(data['encrypted'])
+//         passphrase = data['password']
+//     except (KeyError, base64.binascii.Error) as e:
+//         raise ValueError(f"Invalid input data format: {e}")
+//     # Derive the key using the same parameters as Node.js
+//     kdf = PBKDF2HMAC(
+//         algorithm=hashes.SHA512(),
+//         salt=salt,
+//         iterations=100000,
+//         length=32,
+//         backend=default_backend()
+//     )
+//     key = kdf.derive(passphrase.encode('utf-8'))
+//     # Decrypt the data
+//     cipher = Cipher(algorithms.AES(key), modes.GCM(iv, auth_tag), backend=default_backend())
+//     decryptor = cipher.decryptor()
+//     plaintext = decryptor.update(ciphertext) + decryptor.finalize()
+//     return plaintext.decode('utf-8')
+// if __name__ == '__main__':
+//     # IMPORTANT: Paste the actual result dictionary from your Node.js function here.
+//     # You will need to `console.log` the full result object.
+//     node_js_result = {
+//         "error": False,
+//         "message": "encryption successful",
+//         "salt": "YOUR_BASE64_SALT_HERE",
+//         "vector": "YOUR_BASE64_IV_HERE",
+//         "authTag": "YOUR_BASE64_AUTH_TAG_HERE",
+//         "data": "YOUR_BASE64_CIPHERTEXT_HERE"
+//     }
+//     node_js_result['password'] = "my-super-secret-passphrase"
+//     try:
+//         decrypted_message = decrypt(node_js_result)
+//         print("Python Decrypted:", decrypted_message)
+//     except Exception as e:
+//         print("Decryption error:", e)
+// >> ================================================================================================
+//** GOLANG DECRYPT FOR 'encryptAESGCM2' function */
+// decrypt.go
+// package main
+// import (
+// 	"crypto/aes"
+// 	"crypto/cipher"
+// 	"crypto/pbkdf2"
+// 	"crypto/sha512"
+// 	"encoding/base64"
+// 	"encoding/json"
+// 	"fmt"
+// )
+// // Define a struct that matches the format of your Node.js encryption output.
+// type EncryptedData struct {
+// 	Salt      string `json:"salt"`
+// 	Vector    string `json:"vector"`
+// 	AuthTag   string `json:"authTag"`
+// 	Encrypted string `json:"data"`
+// 	Password  string `json:"password"` // Assuming this would be passed separately
+// }
+// const (
+// 	pbkdf2Iterations = 100000
+// 	keyLength        = 32
+// )
+// // DeriveKey from a passphrase and salt using PBKDF2.
+// func deriveKey(password, salt []byte) []byte {
+// 	return pbkdf2.Key(password, salt, pbkdf2Iterations, keyLength, sha512.New)
+// }
+// // Decrypts an AES-256-GCM encrypted data object.
+// func decrypt(data EncryptedData) (string, error) {
+// 	salt, err := base64.StdEncoding.DecodeString(data.Salt)
+// 	if err != nil {
+// 		return "", fmt.Errorf("invalid salt encoding: %v", err)
+// 	}
+// 	iv, err := base64.StdEncoding.DecodeString(data.Vector)
+// 	if err != nil {
+// 		return "", fmt.Errorf("invalid vector (IV) encoding: %v", err)
+// 	}
+// 	authTag, err := base64.StdEncoding.DecodeString(data.AuthTag)
+// 	if err != nil {
+// 		return "", fmt.Errorf("invalid authTag encoding: %v", err)
+// 	}
+// 	ciphertext, err := base64.StdEncoding.DecodeString(data.Encrypted)
+// 	if err != nil {
+// 		return "", fmt.Errorf("invalid encrypted data encoding: %v", err)
+// 	}
+// 	key := deriveKey([]byte(data.Password), salt)
+// 	block, err := aes.NewCipher(key)
+// 	if err != nil {
+// 		return "", err
+// 	}
+// 	aesGCM, err := cipher.NewGCM(block)
+// 	if err != nil {
+// 		return "", err
+// 	}
+// 	plaintext, err := aesGCM.Open(nil, iv, ciphertext, authTag)
+// 	if err != nil {
+// 		return "", fmt.Errorf("decryption failed, possibly due to incorrect password or corrupted data: %v", err)
+// 	}
+// 	return string(plaintext), nil
+// }
+// func main() {
+// 	// IMPORTANT: Replace this with the actual JSON output from your Node.js function.
+// 	// You will need to print the full result object from your JS function.
+// 	nodeJsResultJSON := `{
+// 		"error": false,
+// 		"message": "encryption successful",
+// 		"salt": "YOUR_BASE64_SALT_HERE",
+// 		"vector": "YOUR_BASE64_IV_HERE",
+// 		"authTag": "YOUR_BASE64_AUTH_TAG_HERE",
+// 		"data": "YOUR_BASE64_CIPHERTEXT_HERE"
+// 	}`
+// 	passphrase := "my-super-secret-passphrase"
+// 	var encryptedData EncryptedData
+// 	err := json.Unmarshal([]byte(nodeJsResultJSON), &encryptedData)
+// 	if err != nil {
+// 		fmt.Println("Error parsing JSON:", err)
+// 		return
+// 	}
+// 	encryptedData.Password = passphrase // Add the password to the struct for the decrypt function
+// 	decrypted, err := decrypt(encryptedData)
+// 	if err != nil {
+// 		fmt.Println("Decryption error:", err)
+// 		return
+// 	}
+// 	fmt.Println("Go Decrypted:", decrypted)
+// }

package/build/utils/types.util.d.ts

@@ -0,0 +1,58 @@
+export type SyncAction = 'user.updated' | 'user.deleted' | 'user.created' | 'country.found' | 'user.apikey' | 'action.update' | 'action.create' | 'audit.created' | 'audit.updated' | 'audit.deleted' | 'notification.created' | 'notification.updated' | 'notification.deleted' | 'action.delete' | 'kyc.updated' | 'kyb.updated';
+export type SyncType = 'type.compliance' | 'type.register' | 'type.login' | 'type.update' | 'typ.delete' | 'type.create' | 'type.audit' | 'type.noitfy' | 'type.password.changed' | 'type.forgot.password' | 'type.invite.user';
+export type SyncNotify = 'notify.sms.otp' | 'notify.email.otp' | 'notify.welcome.email' | 'notify.email.link' | 'notify.compliance' | 'notify.password.changed' | 'notify.forgot.password' | 'notify.invite.user' | 'notify.create' | 'notify.read' | 'notify.delete';
+export type DateCompare = 'equal' | 'greaterthan' | 'lessthan' | 'greaterequal' | 'lessequal';
+export type SentcompPattern = 'in-order' | 'random';
+export type SentcompLikely = 'equal' | 'not-equal' | 'mostly-equal' | 'less-equal' | 'almost-different' | 'different';
+export type FormatDateType = 'basic' | 'datetime' | 'datetime-slash' | 'datetime-separated' | 'separated' | 'localtime' | 'slashed';
+export interface IDateToday {
+    year: number;
+    month: number;
+    monthName: any;
+    date: number;
+    week: number;
+    day: number;
+    dayName: any;
+    hour: number;
+    min: number;
+    sec: number;
+    milli: number;
+    ISO: string;
+    dayjs: any;
+    dateTime: number;
+}
+export interface IMonthsSplit {
+    start: number;
+    end: number;
+    dates: Array<number>;
+}
+export interface IDatesSplit {
+    label: string;
+    start: string;
+    end: string;
+    dates: Array<string>;
+}
+export interface IStringToBase64 {
+    type: 'buffer' | 'direct';
+    payload: string;
+}
+export interface IBase64ToString {
+    type: 'buffer' | 'direct';
+    payload: string;
+}
+export interface IArrayToObject {
+    type: string;
+    key: any;
+    value: any;
+}
+export interface ISlugit {
+    data: string;
+    options?: {
+        lowercase?: boolean;
+        separator?: string;
+    };
+}
+export interface IDateIsPast {
+    currentDate: string;
+    compareDate: string;
+}

package/build/utils/types.util.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@btffamily/vacepey",
+  "version": "1.0.1",
+  "description": "common node.js codebase for vacepay platform",
+  "main": "./build/index.js",
+  "types": "./build/index.d.ts",
+  "files": [
+    "build/**/*",
+    "build/middleware/*",
+    "build/middleware/ca-certificate.crt"
+  ],
+  "scripts": {
+    "clean": "del-cli ./build/*",
+    "copy": "copyfiles -a src/* build",
+    "build": "npm run clean && npm run copy && tsc",
+    "pub": "npm run build && npm publish --access public"
+  },
+  "repository": {
+    "type": "git",
+    "url": ""
+  },
+  "keywords": [
+    "software",
+    "common"
+  ],
+  "author": "BTF Inc.",
+  "license": "MIT",
+  "homepage": "",
+  "dependencies": {
+    "@types/amqplib": "^0.10.3",
+    "@types/colors": "^1.2.1",
+    "@types/express": "^4.17.13",
+    "@types/jsonwebtoken": "^8.5.5",
+    "amqplib": "^0.10.3",
+    "axios": "^1.12.2",
+    "colors": "^1.4.0",
+    "copyfiles": "^2.4.1",
+    "dayjs": "^1.10.7",
+    "del-cli": "^4.0.1",
+    "express": "^4.17.1",
+    "jsonwebtoken": "^8.5.1",
+    "moment": "^2.30.1",
+    "mongoose": "^8.14.2",
+    "node-nats-streaming": "^0.3.2",
+    "redis": "^4.0.6",
+    "slugify": "^1.6.6",
+    "typescript": "^4.4.3"
+  }
+}