Este projeto tem como fins de criar e abstrair módulos basicos e utilidades para o node js
npm install npm-package-nodejs-utils-ldajs
import express from 'express';
import { encryptedPayloadMiddleware } from 'npm-package-nodejs-utils-lda';
const app = express();
app.use(express.json());
app.post('/secure-endpoint', encryptedPayloadMiddleware, (req, res) => {
res.json({ received: req.decryptedBody });
});
app.listen(3000, () => console.log('Servidor rodando na porta 3000'));
`
client mode
🔑 Crypto Client Implementation (Front-end/Node.js)
Para que o cliente (browser, React, ou outro servidor) possa se comunicar com segurança, ele deve:
Buscar a chave RSA pública do servidor (/public-keys/public_key.pem).
Gerar uma chave AES efêmera.
Criptografar a chave AES com a chave RSA pública (Key Exchange).
Criptografar o payload da mensagem com a chave AES (Data Encryption).
Enviar o pacote completo (AES key, IV, AuthTag, Timestamp, Nonce) ao endpoint seguro.
Exemplo de Código do Lado do Cliente (Browser/Web Crypto API)
`js
// crypto_client.js (Implementação de referência)
// 1. Defina a URL da chave pública (deve ser a rota que você expôs)
const PUBLIC_KEY_URL = '/public-keys/public_key.pem';
const API_URL = '/secure-endpoint';
/**
* Converte um buffer para string Base64 (Web-Safe)
* @param {ArrayBuffer} buffer
* @returns {string} Base64 Web-Safe string.
*/
function arrayBufferToBase64(buffer) {
let binary = '';
const bytes = new Uint8Array(buffer);
for (let i = 0; i < bytes.byteLength; i++) {
binary += String.fromCharCode(bytes[i]);
}
return btoa(binary).replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '');
}
/**
* Busca e importa a chave RSA pública do servidor.
* @returns {Promise} Chave RSA importada.
*/
async function getPublicKey() {
const response = await fetch(PUBLIC_KEY_URL);
if (!response.ok) throw new Error('Falha ao buscar chave pública do servidor.');
const pem = await response.text();
// Remove cabeçalho e rodapé PEM e trata Base64
const base64 = pem
.replace('-----BEGIN PUBLIC KEY-----', '')
.replace('-----END PUBLIC KEY-----', '')
.replace(/\s/g, '');
const binaryDer = Uint8Array.from(atob(base64), c => c.charCodeAt(0));
// Importa a chave pública para a Web Crypto API
return crypto.subtle.importKey(
'spki',
binaryDer,
{
name: "RSA-OAEP",
hash: "SHA-256",
},
true,
["wrapKey"]
);
}
/**
* Criptografa o payload para ser enviado ao servidor.
* @param {object} data - O objeto JSON a ser criptografado.
* @returns {Promise `
*
user system
`js
insertUser(name,userdata);
return userdata saved
selectUser(ID);
return userdata
usersList();
return users ID,name
deleteUser(ID);
alterUser(ID, name, newUserData);
disableUser(ID);
reactivateUser(ID);
`
STORAGE
Express (ESM)
`js
import express from "express";
import { saveFile, saveBot } from "npm-package-nodejs-utils-lda";
const app = express();
app.post("/upload/page", saveFile.single("file"), (req, res) => {
res.json({ ok: true, file: req.file });
});
app.post("/upload/bot", saveBot.single("file"), (req, res) => {
res.json({ ok: true, file: req.file });
});
`
mongo DB
`js
mongoConnect(connectionString)
// SET 'MONGO_CONNECTION_STRING' VARIABLE IN .ENV FILE FOR SECURE AND AUTOMATIC CONNECTION
mongoConnect()
// connection = await mongoConnect(connectionString);
select(connection, database, table)
return all data of selected table
insert(connection, database, table, data)
return mongoClient or connection
`
AUTH
`js
const { requestAuthCode } = require("npm-package-nodejs-utils-lda");
/**
* POST /api/auth/request-code
* Body: { email: string }
*/
router.post("/request-code", async (req, res) => {
try {
const { email } = req.body;
if (!email) {
return res.status(400).json({ error: "Email é obrigatório" });
}
await requestAuthCode(email);
return res.status(200).json({
success: true,
message: "Código enviado para o email",
});
} catch (err) {
console.error(err);
return res.status(500).json({
error: "Erro ao enviar código",
});
}
});
module.exports = router;
`
verify codes
`js
const { verifyAuthCode } = require("npm-package-nodejs-utils-lda");
app.post("/api/auth/verify-code", async (req, res) => {
try {
const { email, code } = req.body;
await verifyAuthCode(email, code);
res.json({ success: true });
} catch (err) {
res.status(401).json({ error: err.message });
}
});
`
Generals Usage
``js
import { fopen, fwrite, generateToken, fetchGet } from "npm-package-nodejs-utils-lda";
const filePath = "database.json"
// Usando as funções
const data = fopen(filePath);
data.push("X");
fwrite(filePath, data);
const token = generateToken();
fetchGet("https://example.com",null, (onError,data)=>{
if(onError){
res.send(error);
}
res.send(data);
});
app.get("/baixar", (req, res) => {
const fileUrl = "https://exemplo.com/arquivo.zip"; // URL do arquivo
fetchDownloadStream(fileUrl, (err, fileStream) => {
if (err) {
return res.status(500).send("Erro ao baixar o arquivo.");
}
// Define o cabeçalho para download
res.setHeader("Content-Disposition", 'attachment; filename="arquivo.zip"');
res.setHeader("Content-Type", "application/octet-stream");
// Envia o stream do arquivo para o cliente
fileStream.pipe(res);
});
});
WSChat
With Express (recommended)
If you already have an Express server, just pass the app instance to WSChat:
``js
import express from "express";
import WSChat from "./WSchat.lib.mjs"; // or require() for CommonJS
const app = express();
const server = WSChat(app, {
welcomeMessage: "Hello! Welcome to the chat."
});
server.listen(3000, () => {
console.log("Server running on port 3000");
});
``
This creates the HTTP + WebSocket server using the same Express server.
Without Express (standalone WebSocket server)
If you want to run WSChat alone, without Express:
``js
import WSChat from "./WSchat.lib.mjs";
WSChat(null, { port: 8080 }); // starts HTTP + WS server on port 8080
``
---
Options
The second argument is an optional object with the following properties:
``js
{
port: 8080, // Number - Port to listen on if WSChat creates its own HTTP server (default 8080)
welcomeMessage: "Welcome to WSChat!" // String - Message sent to clients immediately after connection
}
```