@awesomeness-js/utils 1.0.17 → 1.0.19

package/index.js

@@ -6,11 +6,17 @@
 import _build from './src/build.js';
 import _combineFiles from './src/combineFiles.js';
 import _convertBytes from './src/convertBytes.js';
+import _decrypt from './src/decrypt.js';
 import _each from './src/each.js';
 import _eachAsync from './src/eachAsync.js';
+import _encrypt from './src/encrypt.js';
 import _getAllFiles from './src/getAllFiles.js';
+import _ignoreFolder_ignoreMe from './src/ignoreFolder/ignoreMe.js';
+import _ignoreMe from './src/ignoreMe.js';
 import _isUUID from './src/isUUID.js';
 import _md5 from './src/md5.js';
+import _password_check from './src/password/check.js';
+import _password_hash from './src/password/hash.js';
 import _setLocalEnvs from './src/setLocalEnvs.js';
 import _toPennies from './src/toPennies.js';
 import _utils_buildExportsTree from './src/utils/buildExportsTree.js';
@@ -28,9 +34,12 @@ import _uuid from './src/uuid.js';
 export { _build as build };
 export { _combineFiles as combineFiles };
 export { _convertBytes as convertBytes };
+export { _decrypt as decrypt };
 export { _each as each };
 export { _eachAsync as eachAsync };
+export { _encrypt as encrypt };
 export { _getAllFiles as getAllFiles };
+export { _ignoreMe as ignoreMe };
 export { _isUUID as isUUID };
 export { _md5 as md5 };
 export { _setLocalEnvs as setLocalEnvs };
@@ -60,14 +69,24 @@ export default {
      * @returns {string} The converted bytes in a string format with appropriate units.
      */
     convertBytes: _convertBytes,
+    decrypt: _decrypt,
     each: _each,
     eachAsync: _eachAsync,
+    encrypt: _encrypt,
     getAllFiles: _getAllFiles,
+    ignoreMe: _ignoreMe,
     isUUID: _isUUID,
     md5: _md5,
     setLocalEnvs: _setLocalEnvs,
     toPennies: _toPennies,
     uuid: _uuid,
+    ignoreFolder: {
+        ignoreMe: _ignoreFolder_ignoreMe,
+    },
+    password: {
+        check: _password_check,
+        hash: _password_hash,
+    },
     utils: {
         buildExportsTree: _utils_buildExportsTree,
         buildFileDataList: _utils_buildFileDataList,

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@awesomeness-js/utils",
-    "version": "1.0.17",
+    "version": "1.0.19",
     "description": "Awesomeness - Utils",
     "repository": {
       "type": "git",

package/secrets/dev.env

@@ -1 +1,2 @@
-JUST_A_TEST='Dev just a test'
+JUST_A_TEST='Dev just a test'
+AWESOMENESS_ENCRYPTION_KEY='12345678901234567890123456789012'

package/secrets/local.env

@@ -1 +1,2 @@
-JUST_A_TEST='Local just a test'
+JUST_A_TEST='Local just a test'
+AWESOMENESS_ENCRYPTION_KEY='12345678901234567890123456789012'

package/src/decrypt.js

@@ -0,0 +1,17 @@
+import { createDecipheriv } from 'crypto';
+
+export default function decrypt(encryptedData, key = process.env.AWESOMENESS_ENCRYPTION_KEY ?? 'YOU SHOULD HAVE REPLACED THIS... Slacker...') {
+    
+    console.log({ key });
+
+    const { iv, authTag, cipherText } = encryptedData;
+  
+    const decipher = createDecipheriv('aes-256-gcm', key, Buffer.from(iv, 'hex'));
+    decipher.setAuthTag(Buffer.from(authTag, 'hex'));
+  
+    let decrypted = decipher.update(cipherText, 'hex', 'utf8');
+    decrypted += decipher.final('utf8');
+  
+    return decrypted;
+
+}

package/src/encrypt.js

@@ -0,0 +1,26 @@
+import { randomBytes, createCipheriv } from 'crypto';
+
+// Encrypt plaintext using AES-256-GCM
+export default function encrypt(plainText, key = process.env.AWESOMENESS_ENCRYPTION_KEY ?? 'YOU SHOULD HAVE REPLACED THIS... Slacker...') {
+
+    console.log({ key });
+
+    // GCM typically uses a 12- or 16-byte IV/nonce
+    const iv = randomBytes(12);
+
+    const cipher = createCipheriv('aes-256-gcm', key, iv);
+    let encrypted = cipher.update(plainText, 'utf8', 'hex');
+    encrypted += cipher.final('hex');
+
+    // GCM provides an auth tag, which is required for decryption
+    const authTag = cipher.getAuthTag().toString('hex');
+
+    // Return all parts needed for safe decryption
+    return {
+        iv: iv.toString('hex'),
+        authTag,
+        cipherText: encrypted
+    };
+
+}
+

package/src/getAllFiles.js

@@ -3,50 +3,46 @@ import { join } from 'path';
 import shouldIgnore from './utils/shouldIgnore.js';
 
 export default function getAllFiles(base, {
-	dir = '.',
-	files = [], 
-	ignore = [],
-	fileTypes = []
+    dir = '.',
+    files = [], 
+    ignore = [],
+    fileTypes = []
 } = {}) {
 
-	const directory = join(base, dir);
-	const normalizedDir = dir.replace(/\\/g, '/');
-
-	if (ignore.some(pattern => normalizedDir.startsWith(pattern.replace(/\/\*$/, '')))) {
-		return files;
-	}
-
-	const sortedFiles = readdirSync(directory).sort();
-
-	sortedFiles.forEach(file => {
-		
-		const fullPath = join(directory, file);
-		const relativePath = join(dir, file).replace(/\\/g, '/');
-		
-		if (shouldIgnore(relativePath, ignore)) {
-			return;
-		}
-
-		if (statSync(fullPath).isDirectory()) {
-
-			getAllFiles(base, {
-				dir: join(dir, file),
-				files, 
-				ignore
-			});
-
-		} else {
-
-			if(fileTypes.length > 0) {
-				if (!fileTypes.some(ext => file.endsWith(ext))) return;
-			}
-
-			files.push(relativePath);
-
-		}
-
-	});
-
-	return files;
-
-}
+    const directory = join(base, dir);
+
+    const sortedFiles = readdirSync(directory).sort();
+
+    sortedFiles.forEach(file => {
+        const fullPath = join(directory, file);
+        // 1) Generate the original "relative path"
+        const relativePath = join(dir, file).replace(/\\/g, '/');
+
+        // 2) Prepend a slash so patterns like "/css/*.js" will match "/css/some.js"
+        const pathForIgnore = '/' + relativePath.replace(/^\/*/, '');
+
+        // 3) Check with the leading slash path
+        if (shouldIgnore(pathForIgnore, ignore)) {
+            return;
+        }
+
+        // Recurse if it's a directory
+        if (statSync(fullPath).isDirectory()) {
+            getAllFiles(base, {
+                dir: join(dir, file),
+                files,
+                ignore,
+                fileTypes
+            });
+        } else {
+            // Filter by file types if specified
+            if (fileTypes.length > 0 && !fileTypes.some(ext => file.endsWith(ext))) {
+                return;
+            }
+            // 4) Store the original relative path (without leading slash) in `files` if you prefer
+            files.push(relativePath);
+        }
+    });
+
+    return files;
+}

package/src/password/check.js

@@ -0,0 +1,9 @@
+import { pbkdf2Sync } from 'crypto';
+
+// Compare a plain-text password to a stored salt+hash
+export default function validatePassword(password, storedHash) {
+  const [salt, originalHash] = storedHash.split('::');
+  const derivedKey = pbkdf2Sync(password, salt, 100000, 64, 'sha512');
+  return derivedKey.toString('hex') === originalHash;
+}
+

package/src/password/hash.js

@@ -0,0 +1,11 @@
+import { randomBytes, pbkdf2Sync } from 'crypto';
+
+// Hash a password using Node.js built-in crypto (no external deps).
+export default function hashPassword(password) {
+  // Generate a random 16-byte salt
+  const salt = randomBytes(16).toString('hex');
+  // Derive a 64-byte key using PBKDF2 with 100k iterations (adjust as needed)
+  const derivedKey = pbkdf2Sync(password, salt, 100000, 64, 'sha512');
+  // Return salt and hash combined as a single string
+  return `${salt}::${derivedKey.toString('hex')}`;
+}

package/src/utils/shouldIgnore.js

@@ -1,17 +1,43 @@
 export default function shouldIgnore(filePath, ignorePatterns) {
-    const ignore = ignorePatterns.some(pattern => {
-        const normalizedPath = filePath.replace(/\\/g, '/');
-        const normalizedPattern = pattern.replace(/\\/g, '/');
-        if (normalizedPath === normalizedPattern) return true;
+    // filePath is already something like "/css/some.js" 
+    return ignorePatterns.some(pattern => {
+        // pattern might be "/css/*.js" or "/ignoreFolder", etc.
+        let normalizedPattern = pattern.replace(/\\/g, '/');
+
+        // 1) Full directory ignore: "/ignoreFolder" => ignore "/ignoreFolder" + subdirectories
+        //    If the pattern ends with "/", treat it as a directory path.
+        if (!normalizedPattern.includes('*')) {
+            // e.g. "/ignoreFolder/"
+            if (normalizedPattern.endsWith('/')) {
+                normalizedPattern = normalizedPattern.slice(0, -1); // remove trailing slash
+            }
+            return filePath === normalizedPattern || filePath.startsWith(normalizedPattern + '/');
+        }
+
+        // 2) folder/* => Ignore all immediate children in that folder (no subfolders)
         if (normalizedPattern.endsWith('/*')) {
-            const baseDir = normalizedPattern.slice(0, -2);
-            return normalizedPath.startsWith(baseDir + '/');
+            const baseFolder = normalizedPattern.slice(0, -2); // e.g. "/css"
+            // e.g. filePath === "/css/some.js" => startsWith("/css/")
+            // But also ensure there's no further subfolder.
+            return filePath.startsWith(baseFolder + '/') &&
+                   !filePath.slice(baseFolder.length + 1).includes('/');
+        }
+
+        // 3) *.ext => extension-based ignore (any folder)
+        if (normalizedPattern.startsWith('*.')) {
+            const ext = normalizedPattern.slice(1); // remove '*'
+            return filePath.endsWith(ext);
         }
-        if (normalizedPattern.endsWith('/')) {
-            return normalizedPath === normalizedPattern.slice(0, -1) ||
-                   normalizedPath.startsWith(normalizedPattern);
+
+        // 4) folder/*.ext => only files with that extension in that folder (no subfolders)
+        if (normalizedPattern.includes('/*')) {
+            const [baseFolder, ext] = normalizedPattern.split('/*');
+            return filePath.startsWith(baseFolder + '/') &&
+                   filePath.endsWith(ext) &&
+                   !filePath.slice(baseFolder.length + 1).includes('/');
         }
-        return false;
+
+        // 5) Exact match
+        return filePath === normalizedPattern;
     });
-    return ignore;
-}
+}

package/test/ignoreFolder/ignoreMe.js

@@ -0,0 +1,3 @@
+export default function ignoreMeTest() {
+    console.log('I should not be in the build!');
+};

package/test/ignoreFolder2/ignoreMe.js

@@ -0,0 +1,3 @@
+export default function ignoreMeTest() {
+    console.log('I should not be in the build!');
+};

package/test/secret.test.js

@@ -0,0 +1 @@
+// just a test file to ignore

package/test.js

@@ -1,10 +1,17 @@
 import utils from './index.js';
 
-
-let fileList2 = utils.getAllFiles('./secrets', {
-    fileTypes: ['.env'],
-    ignore: ['dev.env']
-});
+let fileList2 = utils.getAllFiles('./test', {
+   // fileTypes: ['.css'],
+   // fileTypes: ['.js'],
+   ignore: [
+        "/ignoreFolder", 
+        "/ignoreFolder2/", 
+        "*.env",
+        "*.test.js",
+        "/css/*.js",
+        "/js/*.css"
+    ]
+})
 
 console.log({fileList2});
 
@@ -32,4 +39,20 @@ await utils.setLocalEnvs('./secrets/local.env');
 console.log('localEnv', process.env.JUST_A_TEST);
 
 await utils.setLocalEnvs('./secrets/dev.env');
-console.log('localEnv', process.env.JUST_A_TEST);
+console.log('localEnv', process.env.JUST_A_TEST);
+
+const storedHash = utils.password.hash('mySecret123');
+console.log('Stored Hash:', storedHash);
+console.log('Is valid (correct password)?', utils.password.check('mySecret123', storedHash));
+console.log('Is valid (wrong password)?', utils.password.check('wrongPassword', storedHash));
+
+
+// Example 256-bit key for AES-256
+// In real usage, store this securely (e.g., an environment variable or key vault).
+
+const secretMessage = 'This is top secret!';
+const encrypted = utils.encrypt(secretMessage);
+console.log('Encrypted Data:', encrypted);
+
+const decrypted = utils.decrypt(encrypted);
+console.log('Decrypted Data:', decrypted);

package/types/decrypt.d.ts

@@ -0,0 +1 @@
+export default function decrypt(encryptedData: any, key?: any): any;

package/types/encrypt.d.ts

@@ -0,0 +1,5 @@
+export default function encrypt(plainText: any, key?: any): {
+    iv: any;
+    authTag: any;
+    cipherText: any;
+};

package/types/hashPassword.d.ts

@@ -0,0 +1 @@
+export default function hashPassword(password: any): string;

package/types/index.d.ts

@@ -6,11 +6,17 @@
 import type _build from './build';
 import type _combineFiles from './combineFiles';
 import type _convertBytes from './convertBytes';
+import type _decrypt from './decrypt';
 import type _each from './each';
 import type _eachAsync from './eachAsync';
+import type _encrypt from './encrypt';
 import type _getAllFiles from './getAllFiles';
+import type _ignoreFolder_ignoreMe from './ignoreFolder/ignoreMe';
+import type _ignoreMe from './ignoreMe';
 import type _isUUID from './isUUID';
 import type _md5 from './md5';
+import type _password_check from './password/check';
+import type _password_hash from './password/hash';
 import type _setLocalEnvs from './setLocalEnvs';
 import type _toPennies from './toPennies';
 import type _utils_buildExportsTree from './utils/buildExportsTree';
@@ -28,9 +34,12 @@ import type _uuid from './uuid';
 export declare const build: typeof _build;
 export declare const combineFiles: typeof _combineFiles;
 export declare const convertBytes: typeof _convertBytes;
+export declare const decrypt: typeof _decrypt;
 export declare const each: typeof _each;
 export declare const eachAsync: typeof _eachAsync;
+export declare const encrypt: typeof _encrypt;
 export declare const getAllFiles: typeof _getAllFiles;
+export declare const ignoreMe: typeof _ignoreMe;
 export declare const isUUID: typeof _isUUID;
 export declare const md5: typeof _md5;
 export declare const setLocalEnvs: typeof _setLocalEnvs;
@@ -60,14 +69,24 @@ declare const _default: {
      * @returns {string} The converted bytes in a string format with appropriate units.
      */
     convertBytes: typeof _convertBytes;
+    decrypt: typeof _decrypt;
     each: typeof _each;
     eachAsync: typeof _eachAsync;
+    encrypt: typeof _encrypt;
     getAllFiles: typeof _getAllFiles;
+    ignoreMe: typeof _ignoreMe;
     isUUID: typeof _isUUID;
     md5: typeof _md5;
     setLocalEnvs: typeof _setLocalEnvs;
     toPennies: typeof _toPennies;
     uuid: typeof _uuid;
+    ignoreFolder: {
+        ignoreMe: typeof _ignoreFolder_ignoreMe,
+    },
+    password: {
+        check: typeof _password_check,
+        hash: typeof _password_hash,
+    },
     utils: {
         buildExportsTree: typeof _utils_buildExportsTree,
         buildFileDataList: typeof _utils_buildFileDataList,

package/types/password/check.d.ts

@@ -0,0 +1 @@
+export default function validatePassword(password: any, storedHash: any): boolean;

package/types/password/hash.d.ts

@@ -0,0 +1 @@
+export default function hashPassword(password: any): string;

package/types/validatePassword.d.ts

@@ -0,0 +1 @@
+export default function validatePassword(password: any, storedHash: any): boolean;