@gustavo-valsechi/utils 1.0.8 → 1.0.9

package/dist/index.d.mts

@@ -44,6 +44,19 @@ declare class Utils {
             totalPage: number;
         };
     };
+    static cryptor: {
+        toBase64: (buffer: ArrayBuffer | Uint8Array) => string;
+        fromBase64: (base64: string) => Uint8Array;
+        deriveKey: (secret: string) => Promise<CryptoKey>;
+        encrypt: (data: any) => Promise<{
+            iv: string;
+            data: string;
+        }>;
+        decrypt: (payload: {
+            iv: string;
+            data: string;
+        }) => Promise<any>;
+    };
 }
 
 export { Utils as default };

package/dist/index.d.ts

@@ -44,6 +44,19 @@ declare class Utils {
             totalPage: number;
         };
     };
+    static cryptor: {
+        toBase64: (buffer: ArrayBuffer | Uint8Array) => string;
+        fromBase64: (base64: string) => Uint8Array;
+        deriveKey: (secret: string) => Promise<CryptoKey>;
+        encrypt: (data: any) => Promise<{
+            iv: string;
+            data: string;
+        }>;
+        decrypt: (payload: {
+            iv: string;
+            data: string;
+        }) => Promise<any>;
+    };
 }
 
 export { Utils as default };

package/dist/index.js

@@ -220,6 +220,65 @@ var Default = {
 };
 var default_default = Default;
 
+// src/cryptor/index.ts
+var IV_LENGTH = 12;
+var SECRET = process.env.AUTH_SECRET || process.env.NEXT_PUBLIC_AUTH_SECRET;
+var Cryptor = {
+  toBase64: (buffer) => {
+    const bytes = buffer instanceof ArrayBuffer ? new Uint8Array(buffer) : buffer;
+    let binary = "";
+    bytes.forEach((b) => binary += String.fromCharCode(b));
+    return btoa(binary);
+  },
+  fromBase64: (base64) => {
+    const binary = atob(base64);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+      bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes;
+  },
+  deriveKey: async (secret) => {
+    const enc = new TextEncoder().encode(secret);
+    const hash = await crypto.subtle.digest("SHA-256", enc);
+    return crypto.subtle.importKey(
+      "raw",
+      hash,
+      { name: "AES-GCM" },
+      false,
+      ["encrypt", "decrypt"]
+    );
+  },
+  encrypt: async (data) => {
+    if (!SECRET) throw new Error("AUTH_SECRET or NEXT_PUBLIC_AUTH_SECRET is required!");
+    const key = await Cryptor.deriveKey(SECRET);
+    const iv = crypto.getRandomValues(new Uint8Array(IV_LENGTH));
+    const encoded = new TextEncoder().encode(JSON.stringify(data));
+    const encrypted = await crypto.subtle.encrypt(
+      { name: "AES-GCM", iv },
+      key,
+      encoded
+    );
+    return {
+      iv: Cryptor.toBase64(iv),
+      data: Cryptor.toBase64(encrypted)
+    };
+  },
+  decrypt: async (payload) => {
+    if (!SECRET) throw new Error("AUTH_SECRET or NEXT_PUBLIC_AUTH_SECRET is required!");
+    const key = await Cryptor.deriveKey(SECRET);
+    const iv = Cryptor.fromBase64(payload.iv);
+    const encrypted = Cryptor.fromBase64(payload.data);
+    const decrypted = await crypto.subtle.decrypt(
+      { name: "AES-GCM", iv },
+      key,
+      encrypted
+    );
+    return JSON.parse(new TextDecoder().decode(decrypted));
+  }
+};
+var cryptor_default = Cryptor;
+
 // src/index.ts
 var Utils = class {
 };
@@ -228,6 +287,7 @@ Utils.format = format_default;
 Utils.mask = mask_default;
 Utils.removeMask = remove_mask_default;
 Utils.default = default_default;
+Utils.cryptor = cryptor_default;
 
 // index.ts
 var index_default = Utils;

package/dist/index.mjs

@@ -184,6 +184,65 @@ var Default = {
 };
 var default_default = Default;
 
+// src/cryptor/index.ts
+var IV_LENGTH = 12;
+var SECRET = process.env.AUTH_SECRET || process.env.NEXT_PUBLIC_AUTH_SECRET;
+var Cryptor = {
+  toBase64: (buffer) => {
+    const bytes = buffer instanceof ArrayBuffer ? new Uint8Array(buffer) : buffer;
+    let binary = "";
+    bytes.forEach((b) => binary += String.fromCharCode(b));
+    return btoa(binary);
+  },
+  fromBase64: (base64) => {
+    const binary = atob(base64);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+      bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes;
+  },
+  deriveKey: async (secret) => {
+    const enc = new TextEncoder().encode(secret);
+    const hash = await crypto.subtle.digest("SHA-256", enc);
+    return crypto.subtle.importKey(
+      "raw",
+      hash,
+      { name: "AES-GCM" },
+      false,
+      ["encrypt", "decrypt"]
+    );
+  },
+  encrypt: async (data) => {
+    if (!SECRET) throw new Error("AUTH_SECRET or NEXT_PUBLIC_AUTH_SECRET is required!");
+    const key = await Cryptor.deriveKey(SECRET);
+    const iv = crypto.getRandomValues(new Uint8Array(IV_LENGTH));
+    const encoded = new TextEncoder().encode(JSON.stringify(data));
+    const encrypted = await crypto.subtle.encrypt(
+      { name: "AES-GCM", iv },
+      key,
+      encoded
+    );
+    return {
+      iv: Cryptor.toBase64(iv),
+      data: Cryptor.toBase64(encrypted)
+    };
+  },
+  decrypt: async (payload) => {
+    if (!SECRET) throw new Error("AUTH_SECRET or NEXT_PUBLIC_AUTH_SECRET is required!");
+    const key = await Cryptor.deriveKey(SECRET);
+    const iv = Cryptor.fromBase64(payload.iv);
+    const encrypted = Cryptor.fromBase64(payload.data);
+    const decrypted = await crypto.subtle.decrypt(
+      { name: "AES-GCM", iv },
+      key,
+      encrypted
+    );
+    return JSON.parse(new TextDecoder().decode(decrypted));
+  }
+};
+var cryptor_default = Cryptor;
+
 // src/index.ts
 var Utils = class {
 };
@@ -192,6 +251,7 @@ Utils.format = format_default;
 Utils.mask = mask_default;
 Utils.removeMask = remove_mask_default;
 Utils.default = default_default;
+Utils.cryptor = cryptor_default;
 
 // index.ts
 var index_default = Utils;

package/dist/src/cryptor/index.d.mts

@@ -0,0 +1,15 @@
+declare const Cryptor: {
+    toBase64: (buffer: ArrayBuffer | Uint8Array) => string;
+    fromBase64: (base64: string) => Uint8Array;
+    deriveKey: (secret: string) => Promise<CryptoKey>;
+    encrypt: (data: any) => Promise<{
+        iv: string;
+        data: string;
+    }>;
+    decrypt: (payload: {
+        iv: string;
+        data: string;
+    }) => Promise<any>;
+};
+
+export { Cryptor as default };

package/dist/src/cryptor/index.d.ts

@@ -0,0 +1,15 @@
+declare const Cryptor: {
+    toBase64: (buffer: ArrayBuffer | Uint8Array) => string;
+    fromBase64: (base64: string) => Uint8Array;
+    deriveKey: (secret: string) => Promise<CryptoKey>;
+    encrypt: (data: any) => Promise<{
+        iv: string;
+        data: string;
+    }>;
+    decrypt: (payload: {
+        iv: string;
+        data: string;
+    }) => Promise<any>;
+};
+
+export { Cryptor as default };

package/dist/src/cryptor/index.js

@@ -0,0 +1,82 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/cryptor/index.ts
+var cryptor_exports = {};
+__export(cryptor_exports, {
+  default: () => cryptor_default
+});
+module.exports = __toCommonJS(cryptor_exports);
+var IV_LENGTH = 12;
+var SECRET = process.env.AUTH_SECRET || process.env.NEXT_PUBLIC_AUTH_SECRET;
+var Cryptor = {
+  toBase64: (buffer) => {
+    const bytes = buffer instanceof ArrayBuffer ? new Uint8Array(buffer) : buffer;
+    let binary = "";
+    bytes.forEach((b) => binary += String.fromCharCode(b));
+    return btoa(binary);
+  },
+  fromBase64: (base64) => {
+    const binary = atob(base64);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+      bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes;
+  },
+  deriveKey: async (secret) => {
+    const enc = new TextEncoder().encode(secret);
+    const hash = await crypto.subtle.digest("SHA-256", enc);
+    return crypto.subtle.importKey(
+      "raw",
+      hash,
+      { name: "AES-GCM" },
+      false,
+      ["encrypt", "decrypt"]
+    );
+  },
+  encrypt: async (data) => {
+    if (!SECRET) throw new Error("AUTH_SECRET or NEXT_PUBLIC_AUTH_SECRET is required!");
+    const key = await Cryptor.deriveKey(SECRET);
+    const iv = crypto.getRandomValues(new Uint8Array(IV_LENGTH));
+    const encoded = new TextEncoder().encode(JSON.stringify(data));
+    const encrypted = await crypto.subtle.encrypt(
+      { name: "AES-GCM", iv },
+      key,
+      encoded
+    );
+    return {
+      iv: Cryptor.toBase64(iv),
+      data: Cryptor.toBase64(encrypted)
+    };
+  },
+  decrypt: async (payload) => {
+    if (!SECRET) throw new Error("AUTH_SECRET or NEXT_PUBLIC_AUTH_SECRET is required!");
+    const key = await Cryptor.deriveKey(SECRET);
+    const iv = Cryptor.fromBase64(payload.iv);
+    const encrypted = Cryptor.fromBase64(payload.data);
+    const decrypted = await crypto.subtle.decrypt(
+      { name: "AES-GCM", iv },
+      key,
+      encrypted
+    );
+    return JSON.parse(new TextDecoder().decode(decrypted));
+  }
+};
+var cryptor_default = Cryptor;

package/dist/src/cryptor/index.mjs

@@ -0,0 +1,61 @@
+// src/cryptor/index.ts
+var IV_LENGTH = 12;
+var SECRET = process.env.AUTH_SECRET || process.env.NEXT_PUBLIC_AUTH_SECRET;
+var Cryptor = {
+  toBase64: (buffer) => {
+    const bytes = buffer instanceof ArrayBuffer ? new Uint8Array(buffer) : buffer;
+    let binary = "";
+    bytes.forEach((b) => binary += String.fromCharCode(b));
+    return btoa(binary);
+  },
+  fromBase64: (base64) => {
+    const binary = atob(base64);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+      bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes;
+  },
+  deriveKey: async (secret) => {
+    const enc = new TextEncoder().encode(secret);
+    const hash = await crypto.subtle.digest("SHA-256", enc);
+    return crypto.subtle.importKey(
+      "raw",
+      hash,
+      { name: "AES-GCM" },
+      false,
+      ["encrypt", "decrypt"]
+    );
+  },
+  encrypt: async (data) => {
+    if (!SECRET) throw new Error("AUTH_SECRET or NEXT_PUBLIC_AUTH_SECRET is required!");
+    const key = await Cryptor.deriveKey(SECRET);
+    const iv = crypto.getRandomValues(new Uint8Array(IV_LENGTH));
+    const encoded = new TextEncoder().encode(JSON.stringify(data));
+    const encrypted = await crypto.subtle.encrypt(
+      { name: "AES-GCM", iv },
+      key,
+      encoded
+    );
+    return {
+      iv: Cryptor.toBase64(iv),
+      data: Cryptor.toBase64(encrypted)
+    };
+  },
+  decrypt: async (payload) => {
+    if (!SECRET) throw new Error("AUTH_SECRET or NEXT_PUBLIC_AUTH_SECRET is required!");
+    const key = await Cryptor.deriveKey(SECRET);
+    const iv = Cryptor.fromBase64(payload.iv);
+    const encrypted = Cryptor.fromBase64(payload.data);
+    const decrypted = await crypto.subtle.decrypt(
+      { name: "AES-GCM", iv },
+      key,
+      encrypted
+    );
+    return JSON.parse(new TextDecoder().decode(decrypted));
+  }
+};
+var cryptor_default = Cryptor;
+export {
+  cryptor_default as default
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gustavo-valsechi/utils",
-  "version": "1.0.8",
+  "version": "1.0.9",
   "main": "dist/index.js",
   "module": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -65,6 +65,11 @@
       "types": "./dist/src/default/index.d.ts",
       "require": "./dist/src/default/index.js",
       "import": "./dist/src/default/index.js"
+    },
+    "./cryptor": {
+      "types": "./dist/src/cryptor/index.d.ts",
+      "require": "./dist/src/cryptor/index.js",
+      "import": "./dist/src/cryptor/index.js"
     }
   }
 }