dff-util 1.0.2 → 1.0.4

package/README.md

@@ -1,3 +1,172 @@
+## Http
+
+```
+Http calls
+```
+
+## util
+
+```
+=> Random number generate.
+AppRandomString(length, charset);
+
+=> Generate code with Upper case without special char
+AppUniqueCode();
+
+=> Key give Upper case without special char by type
+AppCodeByType(name, type);
+
+=> Key give Upper case without special char
+AppCode(name);
+
+AppDaysBack(date, addDays, isDays);
+
+AppAddDays(date, addDays, isDays);
+
+AppUUID4();
+```
+
+## JWT
+
+#### Encode JWT Token with secret key, expiresIn in seconds (86400 = 1 day) default
+
+```
+JwtEncode(data, secret, expiresIn);
+```
+
+#### Deocde JWT Token
+
+```
+JwtDecode(token);
+```
+
+#### Verify JWT token with secret
+
+```
+JwtVerify(data, secret);
+```
+
+#### Check token expires or not
+
+```
+JwtValid(token);
+```
+
+## Constant Values
+
+```
+ConstValue = {
+  // Logical operators
+  AND: '&&',
+  OR: '||',
+  NOT: '!',
+
+  // Common special characters
+  AT: '@',
+  HASH: '#',
+  DOLLAR: '$',
+  PERCENT: '%',
+  CARET: '^',
+  AMPERSAND: '&',
+  ASTERISK: '*',
+  TILDE: '~',
+  COLON: ':',
+  SEMICOLON: ';',
+  DOUBLE_QUOTE: '"',
+  SINGLE_QUOTE: "'",
+  COMMA: ',',
+  PERIOD: '.',
+  SLASH: '/',
+  QUESTION_MARK: '?',
+  PLUS: '+',
+  UNDERSCORE: '_',
+  HYPHEN: '-',
+  EQUALS: '=',
+  BACKSLASH: '\\',
+  PIPE: '|',
+
+  // Space
+  SPACE: ' ',
+  EMPTY: '',
+
+  // Other
+  TRUE: 'true',
+  FALSE: 'false',
+  NULL: 'null',
+  UNDEFINED: 'undefined',
+
+  STR_AND: 'AND',
+  STR_OR: 'OR',
+  STR_NOT: 'NOT',
+};
+```
+
+## Regx
+
+```
+RegExp = {
+  // Matches any non-alphanumeric characters
+  NON_ALPHA_NUMERIC: /[^\w\s]/g,
+
+  // Matches only numeric digits (0-9)
+  DIGITS_ONLY: /^\d+$/,
+
+  // Matches only alphabets (case-insensitive)
+  ALPHABETS_ONLY: /^[a-zA-Z]+$/,
+
+  // Matches alphanumeric characters (letters and digits)
+  ALPHA_NUMERIC: /^[a-zA-Z0-9]+$/,
+
+  // Matches an email address
+  EMAIL: /^[\w.%+-]+@[a-zA-Z\d.-]+\.[a-zA-Z]{2,}$/,
+
+  // Matches a URL
+  URL: /^(https?:\/\/)?([\w.-]+)\.([a-z]{2,6}\.?)(\/[\w.-]*)*\/?$/i,
+
+  // Matches a US phone number (formats like (123) 456-7890, 123-456-7890, etc.)
+  PHONE_US: /^(\(\d{3}\)\s?|\d{3}[-.\s]?)?\d{3}[-.\s]?\d{4}$/,
+
+  // Matches a password with at least one lowercase, one uppercase, one digit, and one special character
+  STRONG_PASSWORD: /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[\W_]).{8,}$/,
+
+  // Matches whitespace characters
+  WHITESPACE: /\s+/g,
+
+  // Matches any HTML tags
+  HTML_TAG: /<\/?[\w\s="/.':;#-\/\?]+>/gi,
+
+  // Matches IPv4 addresses
+  IPV4: /^(25[0-5]|2[0-4]\d|1?\d?\d)(\.(25[0-5]|2[0-4]\d|1?\d?\d)){3}$/,
+
+  // Matches dates in YYYY-MM-DD format
+  DATE_YYYY_MM_DD: /^\d{4}-\d{2}-\d{2}$/,
+
+  // Matches time in HH:MM 24-hour format
+  TIME_HH_MM: /^([01]\d|2[0-3]):([0-5]\d)$/,
+
+  // Matches ISO 8601 datetime format (e.g., 2023-08-15T13:45:30Z, 2023-08-15T13:45:30+05:30)
+  ISO_DATETIME: /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:\d{2})$/,
+
+  // Matches a hexadecimal color code
+  HEX_COLOR: /^#?([a-fA-F0-9]{6}|[a-fA-F0-9]{3})$/,
+
+  // Matches a UUID (version 4)
+  UUID_V4: /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
+
+  // Matches non-ASCII characters
+  NON_ASCII: /[^\x00-\x7F]/g,
+
+  // Matches line breaks (newlines)
+  LINE_BREAK: /\r?\n/g,
+
+  // Matches amounts in decimal format (e.g., 123.45, 0.99, 1000)
+  AMOUNT_DECIMAL: /^\d+(\.\d{1,2})?$/,
+
+  // Matches percentages from 0-100 or in decimal format (e.g., 25%, 99.99%, 100, 0.5)
+  PERCENTAGE: /^(100(\.0{1,2})?|0|0?\.\d{1,2}|[1-9]?\d(\.\d{1,2})?)%?$/,
+};
+```
+
 ## Session Info
 
 ```
@@ -9,7 +178,21 @@ export type SessionInfo = {
   role: string;
   requestId?: string;
   token?: string;
+  iat?: number;
   exp?: number;
+  key: string;
+};
+```
+
+## SessionUser
+
+```
+export type SessionUser = {
+  id: string;
+  email?: string;
+  mobile?: string;
+  name?: string;
+  role: string;
 };
 ```
 
@@ -23,24 +206,97 @@ new ErrorResponse(message): {
 }
 ```
 
-### util
+## SuccessResponse
+
+```
+export const SuccessResponse = (data: any) => {
+  return {
+    status: 1,
+    type: 'SUCCESS',
+    data: data,
+  };
+};
+```
+
+## file upload test
 
 ```
-UniqueCode();
-UniqueByType(name, type) =>  key give Upper case without special char by type
-Key(name) =>  key give Upper case without special char
-DaysBack(date, addDays, isDays)
-AddDays(date, addDays, isDays)
+// ts-node test/fileupload.ts
+
+import fs from 'fs/promises';
+import { Http } from '../src';
+import path from 'path';
+
+const url = '/file';
+const filename = 'testing2.xlsx';
+const filePath = path.join(__dirname, filename);
+console.log(filePath);
+const main = async () => {
+  const data = await fs.readFile(filePath);
+  const resp = await Http.Upload(
+    url,
+    new File([data], filePath, {
+      type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+      lastModified: Date.now(),
+    }),
+  );
+  console.log('Http.Upload :: ', resp);
+};
+
+main();
 ```
 
-## Crypto encrypt
+## crypto
 
 ```
-crypto.encrypt(text, key) :: string
+const hexStringToArrayBuffer = (hex: string) => {
+  const hexMatches = hex.match(/.{1,2}/g) || [];
+  const typedArray = new Uint8Array(hexMatches.map((byte) => parseInt(byte, 16)));
+  return typedArray.buffer;
+};
+
+export const Decrypt = async (text: string, key: string) => {
+  const [ivHex, dataHex] = text.split(':');
+  const iv = hexStringToArrayBuffer(ivHex);
+  const data = hexStringToArrayBuffer(dataHex);
+  const alg = { name: 'AES-CBC', iv: iv };
+  const cryptoKey = await crypto.subtle.importKey('raw', hexStringToArrayBuffer(key), alg, false, ['decrypt']);
+  const decrypted = await crypto.subtle.decrypt(alg, cryptoKey, data);
+  const dec = new TextDecoder();
+  return dec.decode(decrypted);
+};
 ```
 
-## Crypto decrypt
+```
+import * as crypto from 'crypto';
+export const Encrypt = (text: string, key: string) => {
+  const iv = crypto.randomBytes(16);
+  const cipher = crypto.createCipheriv('aes-256-cbc', Buffer.from(key, 'hex'), iv);
+  let encrypted = cipher.update(text, 'utf8', 'hex');
+  encrypted += cipher.final('hex');
+  return iv.toString('hex') + ':' + encrypted;
+};
+```
 
 ```
-crypto.decrypt(text, key) :: string
+// ts-node test/test.ts
+import crypto from 'crypto';
+
+import { Encrypt, Decrypt } from '../src/index';
+
+//const key = crypto.randomBytes(32).toString('hex');
+const key = '7e0a0ef142de22eb787b5001b36f188f3e7378abf250fc87bf38a4bda197236ef';
+
+console.log(key);
+
+const password = Encrypt('Admin!Admin', key);
+
+console.log(password);
+
+const main = async () => {
+  const resp = await Decrypt(password, key);
+  console.log(resp);
+};
+
+main();
 ```

package/dist/index.d.ts

@@ -1,6 +1,4 @@
 export * from './main/util';
-export * from './main/crypto-decrypt';
-export * from './main/crypto-encrypt';
 export * from './main/jwt-util';
 export * from './main/http';
 export * from './main/regexr';

package/dist/index.js

@@ -15,8 +15,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./main/util"), exports);
-__exportStar(require("./main/crypto-decrypt"), exports);
-__exportStar(require("./main/crypto-encrypt"), exports);
 __exportStar(require("./main/jwt-util"), exports);
 __exportStar(require("./main/http"), exports);
 __exportStar(require("./main/regexr"), exports);

package/dist/main/const-type.d.ts

@@ -6,7 +6,9 @@ export type SessionInfo = {
     role: string;
     requestId?: string;
     token?: string;
+    iat?: number;
     exp?: number;
+    key: string;
 };
 export type SessionUser = {
     id: string;

package/dist/main/http.d.ts

@@ -23,6 +23,6 @@ export declare class Http {
     static Put(url: string, data: any, headers: any, type?: RespType): Promise<any>;
     static Delete(url: string, params: any, headers: any, type?: RespType): Promise<any>;
     static Token(sessionInfo: any, appKey: string, apiKey?: string, type?: RespType): Promise<any>;
-    static Upload(fullUrl: string, file: File, isHeadersAddMultiForm?: boolean, data?: Record<string, any>, headers?: any, type?: RespType): Promise<any>;
-    static Download(fullUrl: string, params: any, headers?: any): Promise<Buffer>;
+    static Upload(fullUrl: string, file: File, isHeadersAddMultiForm?: boolean, data?: Record<string, any>, headers?: any, method?: 'POST' | 'PUT', type?: RespType): Promise<any>;
+    static Download(fullUrl: string, params: any, headers?: any, method?: string): Promise<Buffer>;
 }

package/dist/main/http.js

@@ -127,7 +127,7 @@ class Http {
         });
     }
     static Upload(fullUrl_1, file_1) {
-        return __awaiter(this, arguments, void 0, function* (fullUrl, file, isHeadersAddMultiForm = false, data = {}, headers = exports.BaseHeaders, type = RespType.JSON) {
+        return __awaiter(this, arguments, void 0, function* (fullUrl, file, isHeadersAddMultiForm = false, data = {}, headers = exports.BaseHeaders, method = 'PUT', type = RespType.JSON) {
             const formData = new FormData();
             console.log(file);
             formData.append('file', file);
@@ -141,7 +141,7 @@ class Http {
             }
             try {
                 const requestOptions = {
-                    method: 'POST',
+                    method: method,
                     body: formData,
                     headers: Object.assign({}, headers),
                 };
@@ -156,10 +156,10 @@ class Http {
         });
     }
     static Download(fullUrl_1, params_1) {
-        return __awaiter(this, arguments, void 0, function* (fullUrl, params, headers = exports.HttpHeaders) {
+        return __awaiter(this, arguments, void 0, function* (fullUrl, params, headers = exports.HttpHeaders, method = 'GET') {
             fullUrl = params ? `${fullUrl}?${new URLSearchParams(params).toString()}` : fullUrl;
             try {
-                const requestOptions = { method: 'GET', headers: headers || exports.HttpHeaders };
+                const requestOptions = { method: method, headers: headers || exports.HttpHeaders };
                 const response = yield fetch(fullUrl, requestOptions);
                 const blob = yield response.blob();
                 const buffer = Buffer.from(yield blob.arrayBuffer());

package/dist/main/jwt-util.d.ts

@@ -1,4 +1,28 @@
 import * as jwt from 'jsonwebtoken';
-export declare const JwtEncode: (data: any, token: string, expiresIn?: number) => string;
-export declare const JwtVerify: (data: any, token: string) => string | jwt.JwtPayload;
-export declare const JwtDecode: (token: any) => string | jwt.JwtPayload | null;
+/**
+ * Encode JWT Token with secret key, expiresIn in seconds (86400 = 1 day) default
+ * @param data
+ * @param token
+ * @param expiresIn
+ * @returns
+ */
+export declare const JwtEncode: (data: any, secret: string, expiresIn?: number) => string;
+/**
+ * Verify JWT token with secret
+ * @param data
+ * @param token
+ * @returns
+ */
+export declare const JwtVerify: (data: string, secret: string) => string | jwt.JwtPayload;
+/**
+ * Deocde JWT Token
+ * @param token
+ * @returns
+ */
+export declare const JwtDecode: (token: string) => string | jwt.JwtPayload | null;
+/**
+ * checking token expires or not
+ * @param token
+ * @returns
+ */
+export declare const JwtValid: (token: string) => boolean;

package/dist/main/jwt-util.js

@@ -23,20 +23,33 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.JwtDecode = exports.JwtVerify = exports.JwtEncode = void 0;
+exports.JwtValid = exports.JwtDecode = exports.JwtVerify = exports.JwtEncode = void 0;
 const jwt = __importStar(require("jsonwebtoken"));
-const JwtEncode = (data, token, expiresIn = 86400) => {
-    return jwt.sign(data, token, {
+/**
+ * Encode JWT Token with secret key, expiresIn in seconds (86400 = 1 day) default
+ * @param data
+ * @param token
+ * @param expiresIn
+ * @returns
+ */
+const JwtEncode = (data, secret, expiresIn = 86400) => {
+    return jwt.sign(data, secret, {
         expiresIn: expiresIn,
     });
 };
 exports.JwtEncode = JwtEncode;
-const JwtVerify = (data, token) => {
+/**
+ * Verify JWT token with secret
+ * @param data
+ * @param token
+ * @returns
+ */
+const JwtVerify = (data, secret) => {
     if (data) {
         try {
             data = data.replace('jwt ', '').replace('JWT ', '');
             data = data.replace('Bearer ', '').replace('bearer ', '').replace('BEARER', '');
-            return jwt.verify(data, token);
+            return jwt.verify(data, secret);
         }
         catch (err) {
             throw { name: 'error', message: 'Token is not valid' };
@@ -47,6 +60,11 @@ const JwtVerify = (data, token) => {
     }
 };
 exports.JwtVerify = JwtVerify;
+/**
+ * Deocde JWT Token
+ * @param token
+ * @returns
+ */
 const JwtDecode = (token) => {
     if (token) {
         try {
@@ -64,3 +82,27 @@ const JwtDecode = (token) => {
     }
 };
 exports.JwtDecode = JwtDecode;
+/**
+ * checking token expires or not
+ * @param token
+ * @returns
+ */
+const JwtValid = (token) => {
+    try {
+        if (!token) {
+            return false;
+        }
+        const payloadBase64 = token.split('.')[1];
+        const payload = JSON.parse(atob(payloadBase64));
+        const currentTime = Math.floor(Date.now() / 1000);
+        if (payload.exp && payload.exp < currentTime) {
+            return false;
+        }
+        return true;
+    }
+    catch (error) {
+        console.error('Invalid JWT:', error);
+        return false;
+    }
+};
+exports.JwtValid = JwtValid;

package/dist/main/util.d.ts

@@ -1,7 +1,7 @@
 export declare const AppRandomString: (length: number, charset: string) => string;
 export declare const AppUniqueCode: () => string;
-export declare const AppUniqueCodeByType: (name: string, type?: null) => string;
-export declare const AppKey: (name: string) => string | null;
+export declare const AppCodeByType: (name: string, type?: null) => string;
+export declare const AppCode: (name: string) => string | null;
 export declare const AppDaysBack: (date: Date, backValue: number, isDays?: boolean) => Date;
 export declare const AppAddDays: (date: Date, addDays: number, isDays?: boolean) => Date;
 export declare const AppUUID4: () => string;

package/dist/main/util.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AppUUID4 = exports.AppAddDays = exports.AppDaysBack = exports.AppKey = exports.AppUniqueCodeByType = exports.AppUniqueCode = exports.AppRandomString = void 0;
+exports.AppUUID4 = exports.AppAddDays = exports.AppDaysBack = exports.AppCode = exports.AppCodeByType = exports.AppUniqueCode = exports.AppRandomString = void 0;
 const randomstring_1 = require("randomstring");
 const regexr_1 = require("./regexr");
 const AppRandomString = (length, charset) => {
@@ -18,7 +18,7 @@ const AppUniqueCode = () => {
     return time.toString(36).toUpperCase();
 };
 exports.AppUniqueCode = AppUniqueCode;
-const AppUniqueCodeByType = (name, type = null) => {
+const AppCodeByType = (name, type = null) => {
     let str = '';
     if (type) {
         str = type + '_' + name;
@@ -31,8 +31,8 @@ const AppUniqueCodeByType = (name, type = null) => {
     str = str.substr(0, 128);
     return str.toUpperCase();
 };
-exports.AppUniqueCodeByType = AppUniqueCodeByType;
-const AppKey = (name) => {
+exports.AppCodeByType = AppCodeByType;
+const AppCode = (name) => {
     if (name == null)
         return null;
     let str = '';
@@ -41,7 +41,7 @@ const AppKey = (name) => {
     str = str.replace(/\s/g, '_');
     return str.toUpperCase();
 };
-exports.AppKey = AppKey;
+exports.AppCode = AppCode;
 const AppDaysBack = (date, backValue, isDays = true) => {
     date = new Date(date);
     if (isDays) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dff-util",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {

package/dist/main/crypto-decrypt.d.ts

@@ -1 +0,0 @@
-export declare const Decrypt: (text: string, key: string) => Promise<string>;

package/dist/main/crypto-decrypt.js

@@ -1,28 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Decrypt = void 0;
-const hexStringToArrayBuffer = (hex) => {
-    const hexMatches = hex.match(/.{1,2}/g) || [];
-    const typedArray = new Uint8Array(hexMatches.map((byte) => parseInt(byte, 16)));
-    return typedArray.buffer;
-};
-const Decrypt = (text, key) => __awaiter(void 0, void 0, void 0, function* () {
-    const [ivHex, dataHex] = text.split(':');
-    const iv = hexStringToArrayBuffer(ivHex);
-    const data = hexStringToArrayBuffer(dataHex);
-    const alg = { name: 'AES-CBC', iv: iv };
-    const cryptoKey = yield crypto.subtle.importKey('raw', hexStringToArrayBuffer(key), alg, false, ['decrypt']);
-    const decrypted = yield crypto.subtle.decrypt(alg, cryptoKey, data);
-    const dec = new TextDecoder();
-    return dec.decode(decrypted);
-});
-exports.Decrypt = Decrypt;

package/dist/main/crypto-encrypt.d.ts

@@ -1 +0,0 @@
-export declare const Encrypt: (text: string, key: string) => string;

package/dist/main/crypto-encrypt.js

@@ -1,35 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Encrypt = void 0;
-const crypto = __importStar(require("crypto"));
-const Encrypt = (text, key) => {
-    const iv = crypto.randomBytes(16);
-    const cipher = crypto.createCipheriv('aes-256-cbc', Buffer.from(key, 'hex'), iv);
-    let encrypted = cipher.update(text, 'utf8', 'hex');
-    encrypted += cipher.final('hex');
-    return iv.toString('hex') + ':' + encrypted;
-};
-exports.Encrypt = Encrypt;