@starklabs/backend-core 1.1.1 → 1.2.0

package/dist/js/utils/libsodium.js

@@ -1,9 +1,9 @@
 import sodium from "libsodium-wrappers-sumo";
 import AppError from "./AppError.js";
-// import envs from "../config/envs.js";
 
 // Hash password
 export const hash = async (password) => {
+  if (!password) throw new AppError("String/password is required to hash.");
   await sodium.ready;
 
   const salt = sodium.randombytes_buf(sodium.crypto_pwhash_SALTBYTES);
@@ -23,6 +23,10 @@ export const hash = async (password) => {
 
 // verifyPassword
 export const verifyHash = async (password, storedHash) => {
+  if (!password) throw new AppError("String/password is required to verify");
+  if (!storedHash)
+    throw new AppError("storedHash is required for verification");
+
   await sodium.ready;
 
   const [saltB64, hashB64] = storedHash.split(":");
@@ -63,7 +67,10 @@ export const generateJWTSecret = async () => {
   const secret = sodium.randombytes_buf(64);
 
   // Convert to base64 for .env storage
-  const base64Secret = sodium.to_base64(secret, sodium.base64_variants.ORIGINAL);
+  const base64Secret = sodium.to_base64(
+    secret,
+    sodium.base64_variants.ORIGINAL,
+  );
   console.log(base64Secret);
   return base64Secret;
 };
@@ -71,6 +78,9 @@ export const generateJWTSecret = async () => {
 // seal
 export const seal = async (string, masterKey) => {
   try {
+    if (!string) throw new Error("Data is required to encrypt");
+    if (!masterKey) throw new Error("masterKey is required for encryption");
+
     await sodium.ready;
 
     const keyPair = sodium.crypto_box_keypair();
@@ -106,7 +116,13 @@ export const seal = async (string, masterKey) => {
 };
 
 // unSeal
-export const unSeal = async (str, nonce, publicKey, securedPrivateKey, masterKey) => {
+export const unSeal = async (
+  str,
+  nonce,
+  publicKey,
+  securedPrivateKey,
+  masterKey,
+) => {
   try {
     if (!str || !nonce || !publicKey || !securedPrivateKey)
       throw new AppError(

package/dist/js/utils/rateLimiter.js

@@ -0,0 +1,25 @@
+import rateLimit from "express-rate-limit";
+import getDuration from "../config/duration.js";
+import AppError from "./AppError.js";
+
+export const apiLimiter = ({
+  rateLimitDuration,
+  maxReqLimit,
+  rateLimitMsg,
+}) => {
+  if (!rateLimitDuration || !maxReqLimit || !rateLimitMsg)
+    throw new AppError(
+      "rateLimitDuration, maxReqLimit and rateLimitMsg are required",
+    );
+
+  return rateLimit({
+    windowMs: getDuration(rateLimitDuration) || 15 * 60 * 1000, // 15 minutes
+    max: maxReqLimit || 200, // limit each IP to 200 requests per windowMs
+    standardHeaders: true,
+    legacyHeaders: false,
+    message: {
+      success: false,
+      message: rateLimitMsg || "Too many requests, please try again later.",
+    },
+  });
+};

package/dist/js/utils/uploadFile.js

@@ -0,0 +1,43 @@
+import { getConfig } from "../config/config.js";
+import { cloudinary, upload } from "../config/cloudinary.js";
+import AppError from "./AppError.js";
+import AppLog from "./AppLog.js";
+
+const uploadFile = async (fileData, uploadFolderName) => {
+  try {
+    if (!fileData) throw new Error("fileData not found");
+    if (!uploadFolderName) throw new Error("uploadFolder is required");
+
+    const uploadResult = await new Promise((resolve, reject) => {
+      const stream = cloudinary.uploader.upload_stream(
+        {
+          resource_type: "auto",
+          folder: uploadFolderName,
+        },
+        (error, result) => {
+          if (error) return reject(error);
+          resolve(result);
+        },
+      );
+
+      stream.end(fileData.buffer);
+    });
+
+    if (uploadResult.name === "Error")
+      throw new AppError(uploadResult.message.split(".")[0]);
+
+    const { public_id, secure_url, width, height } = uploadResult;
+
+    return {
+      public_id,
+      secure_url,
+      width,
+      height,
+    };
+  } catch (error) {
+    throw new AppError(error.message);
+    AppLog("X", "uploadFile", error.message);
+  }
+};
+
+export default uploadFile;

package/handlerMap.js

@@ -0,0 +1,33 @@
+const handlerMap = {
+  // Auth
+  login: "Authenticate a user",
+  signup: "Register a new user",
+  logout: "Sign out a user",
+  resendOTP: "Resend one-time password",
+  twoFactorAuth: "Verify two-factor authentication",
+  forgotPassword: "Request password reset",
+  resetPassword: "Reset password",
+  changePassword: "Change password",
+  verifyEmail: "Verify email address",
+  refreshToken: "Refresh access token",
+  deleteAccount: "Delete current account",
+
+  // Generic CRUD
+  getAll: "Get all resources",
+  getById: "Get a resource by ID",
+  create: "Create a resource",
+  update: "Update a resource",
+  patch: "Partially update a resource",
+  delete: "Delete a resource",
+
+  // Query
+  search: "Search resources",
+  filter: "Filter resources",
+  paginate: "Get paginated resources",
+  count: "Get resource count",
+
+  // Files
+  uploadFile: "Upload a file",
+  downloadFile: "Download a file",
+  deleteFile: "Delete a file",
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@starklabs/backend-core",
-  "version": "1.1.1",
+  "version": "1.2.0",
   "description": "A comprehensive backend authentication library featuring MongoDB integration, JWT-based authentication, encryption/decryption using libsodium, and utilities for error handling and logging. Supports both ES modules and CommonJS. Requires MONGODB_URI, DB_NAME, MASTER_KEY, and JWT_SECRET environment variables.",
   "keywords": [
     "auth-mongo",
@@ -9,20 +9,33 @@
   "license": "ISC",
   "author": "Musa",
   "type": "module",
-  "main": "index.js",
+  "main": "./dist/index.js",
   "scripts": {
-    "test": "node test.js"
+    "test": "node test.js",
+    "env-open": "npx dotenv-vault@latest open",
+    "env-push": "npx dotenv-vault@latest push",
+    "env-pull": "npx dotenv-vault@latest pull",
+    "env-login": "npx dotenv-vault@latest login",
+    "env-new": "npx dotenv-vault@latest new"
   },
   "dependencies": {
+    "cloudinary": "^2.10.0",
     "cookie-parser": "^1.4.7",
     "cors": "^2.8.6",
     "dotenv": "^17.4.2",
     "express": "^5.2.1",
-    "helmet": "^8.1.0",
+    "express-rate-limit": "^8.5.2",
+    "helmet": "^8.2.0",
     "jsonwebtoken": "^9.0.3",
     "libsodium-wrappers-sumo": "^0.8.4",
     "mongoose": "^9.6.1",
+    "multer": "^2.2.0",
     "resend": "^6.12.2",
     "zod": "^4.4.1"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js"
+    }
   }
 }

package/test.js

@@ -0,0 +1,36 @@
+import StarkCore, { startServer } from "./dist/js/index.js";
+import "dotenv/config";
+
+import {
+  authCollection,
+  usersCollection,
+  productCollection,
+  healthCollection,
+} from "./collections/index.js";
+
+const core = StarkCore.create({
+  port: Number.parseInt(process.env.PORT),
+  collections: [
+    authCollection,
+    usersCollection,
+    productCollection,
+    healthCollection,
+  ],
+  apiVersion: process.env.API_VERSION,
+  jwtSecret: process.env.JWT_SECRET,
+  isOffline: process.env.ISOFFLINE === "true",
+  masterKey: process.env.MASTER_KEY,
+  ENV: process.env.ENV,
+  tokenExpiry: process.env.TOKEN_EXPIRY,
+  internalRoles: JSON.parse(process.env.INTERNAL_ROLES),
+  resendAPIKey: process.env.RESEND_API_KEY,
+  rateLimitDuration: process.env.RATE_LIMIT_DURATION,
+  maxReqLimit: Number.parseInt(process.env.RATE_LIMIT_REQ),
+  rateLimitMsg: process.env.RATE_LIMIT_MSG,
+  cloudinaryAPIKey: process.env.CLOUDINARY_API_KEY,
+  cloudinaryCloudName: process.env.CLOUDINARY_CLOUD_NAME,
+  cloudinaryAPISecret: process.env.CLOUDINARY_API_SECRET,
+  cloudinaryFolderName: process.env.CLOUDINARY_FOLDER_NAME,
+});
+
+startServer();

package/dist/cjs/db.cjs

@@ -1,17 +0,0 @@
-const mongoose = require("mongoose");
-const AppLog = require("./utils/AppLog.cjs");
-
-// connecting to db
-const connectDB = async (uri, db) => {
-  const mongodbUri = uri || "mongodb://localhost:27017";
-  try {
-    await mongoose.connect(`${mongodbUri}/${db || "test"}`);
-    AppLog("check", "db.js", "Connected successfully!");
-  } catch (error) {
-    AppLog("X", "db.js", "Error while connecting!");
-    AppLog("X", "db.js", error.message);
-  }
-};
-
-// export
-module.exports = connectDB;

package/dist/cjs/index.cjs

@@ -1,59 +0,0 @@
-const connectDB = require("./db.cjs");
-const { seal, unSeal, generateMasterKey, generateJWTSecret, hash, verifyHash } = require("./utils/libsodium.cjs");
-const { signJWT, verifyJWT } = require("./utils/jwt.cjs");
-
-const privateKeys = new WeakMap();
-
-class StarkAuth {
-  constructor(config) {
-    privateKeys.set(this, {
-      _masterKey: config.MASTER_KEY,
-      _JWT_SECRET: config.JWT_SECRET,
-      _JWT_EXPIRY: config.JWT_EXPIRY,
-    });
-  }
-
-  static async create(config) {
-    await connectDB(config.MONGODB_URI, config.DB_NAME);
-    return new StarkAuth(config);
-  }
-
-  async encrypt(str) {
-    const { _masterKey } = privateKeys.get(this);
-    return seal(str, _masterKey);
-  }
-
-  async decrypt(str, nonce, publicKey, securedPrivateKey) {
-    const { _masterKey } = privateKeys.get(this);
-    return unSeal(str, nonce, publicKey, securedPrivateKey, _masterKey);
-  }
-
-  signJWT(payLoad) {
-    const { _JWT_SECRET, _JWT_EXPIRY } = privateKeys.get(this);
-    return signJWT(payLoad, _JWT_SECRET, _JWT_EXPIRY);
-  }
-
-  verifyJWT(token) {
-    const { _JWT_SECRET } = privateKeys.get(this);
-    return verifyJWT(token, _JWT_SECRET);
-  }
-}
-
-module.exports = StarkAuth;
-
-const crypto = {
-  generateMasterKey,
-  generateJWTSecret,
-  hash,
-  verifyHash,
-};
-
-const AppError = require("./utils/AppError.cjs");
-const AppLog = require("./utils/AppLog.cjs");
-const asyncHandler = require("./utils/asyncHandler.cjs");
-
-module.exports = StarkAuth;
-module.exports.crypto = crypto;
-module.exports.AppError = AppError;
-module.exports.AppLog = AppLog;
-module.exports.asyncHandler = asyncHandler;

package/dist/cjs/utils/AppError.cjs

@@ -1,13 +0,0 @@
-// custom error class
-class AppError extends Error {
-  // constructor
-  constructor(message, statusCode) {
-    // calling parent constructor
-    super(message);
-
-    this.statusCode = statusCode;
-    this.isOperational = true;
-  }
-}
-
-module.exports = AppError;

package/dist/cjs/utils/AppLog.cjs

@@ -1,13 +0,0 @@
-// emojis object
-const emojis = {
-  check: "✅",
-  X: "❌",
-};
-
-// console logs
-const AppLog = (emoji, file, message) => {
-  console.log(`${emojis[emoji]} [${file}] ${message}`);
-};
-
-// export
-module.exports = AppLog;

package/dist/cjs/utils/asyncHandler.cjs

@@ -1,6 +0,0 @@
-// async handler wrapper
-const asyncHandler = (fn) => async (req, res, next) => {
-  Promise.resolve(fn(req, res, next)).catch(next);
-};
-
-module.exports = asyncHandler;

package/dist/cjs/utils/jwt.cjs

@@ -1,38 +0,0 @@
-const jwt = require("jsonwebtoken");
-const AppError = require("./AppError.cjs");
-
-const EXPIRY = {
-  "2m": 1000 * 60 * 2,
-  "10m": 1000 * 60 * 10,
-  "1h": 1000 * 60 * 60,
-  "6h": 1000 * 60 * 60 * 6,
-  "12h": 1000 * 60 * 60 * 12,
-  "1d": 1000 * 60 * 60 * 24,
-  "3d": 1000 * 60 * 60 * 24 * 3,
-  "7d": 1000 * 60 * 60 * 24 * 7,
-  "14d": 1000 * 60 * 60 * 24 * 14,
-  "30d": 1000 * 60 * 60 * 24 * 30,
-};
-
-const getExpiry = (key) => {
-  if (!EXPIRY[key]) throw new Error("Invalid expiry key");
-  return EXPIRY[key];
-};
-
-const signJWT = (payLoad, JWT_SECRET, JWT_EXPIRY) => {
-  try {
-    return jwt.sign(payLoad, JWT_SECRET, { expiresIn: JWT_EXPIRY });
-  } catch (error) {
-    throw new AppError(error.message);
-  }
-};
-
-const verifyJWT = (token, JWT_SECRET) => {
-  try {
-    return jwt.verify(token, JWT_SECRET);
-  } catch (error) {
-    throw new AppError("Invalid or expired token", 401);
-  }
-};
-
-module.exports = { EXPIRY, signJWT, verifyJWT };

package/dist/cjs/utils/libsodium.cjs

@@ -1,145 +0,0 @@
-const sodium = require("libsodium-wrappers-sumo");
-const AppError = require("./AppError.cjs");
-
-// Hash password
-const hash = async (password) => {
-  await sodium.ready;
-
-  const salt = sodium.randombytes_buf(sodium.crypto_pwhash_SALTBYTES);
-
-  const hashStr = sodium.crypto_pwhash(
-    32,
-    password,
-    salt,
-    sodium.crypto_pwhash_OPSLIMIT_INTERACTIVE,
-    sodium.crypto_pwhash_MEMLIMIT_INTERACTIVE,
-    sodium.crypto_pwhash_ALG_DEFAULT
-  );
-
-  // store salt + hashStr together
-  return sodium.to_base64(salt) + ":" + sodium.to_base64(hashStr);
-};
-
-// verifyPassword
-const verifyHash = async (password, storedHash) => {
-  await sodium.ready;
-
-  const [saltB64, hashB64] = storedHash.split(":");
-
-  const salt = sodium.from_base64(saltB64);
-  const originalHash = sodium.from_base64(hashB64);
-
-  const testHash = sodium.crypto_pwhash(
-    32,
-    password,
-    salt,
-    sodium.crypto_pwhash_OPSLIMIT_INTERACTIVE,
-    sodium.crypto_pwhash_MEMLIMIT_INTERACTIVE,
-    sodium.crypto_pwhash_ALG_DEFAULT
-  );
-
-  return sodium.memcmp(originalHash, testHash);
-};
-
-// generate master key
-const generateMasterKey = async () => {
-  await sodium.ready;
-
-  const key = sodium.crypto_secretbox_keygen();
-
-  const base64Key = sodium.to_base64(
-    key,
-    sodium.base64_variants.ORIGINAL
-  );
-
-
-  console.log(base64Key);
-  return base64Key
-};
-
-// generate JWT secret
-const generateJWTSecret = async () => {
-  await sodium.ready;
-
-  const secret = sodium.randombytes_buf(64);
-
-  const base64Secret = sodium.to_base64(secret, sodium.base64_variants.ORIGINAL);
-  console.log(base64Secret);
-  return base64Secret;
-};
-
-// seal
-const seal = async (string, masterKey) => {
-  try {
-    await sodium.ready;
-
-    const keyPair = sodium.crypto_box_keypair();
-    const strBytes = sodium.from_string(string);
-
-    const encrypted = sodium.crypto_box_seal(strBytes, keyPair.publicKey);
-    const str = sodium.to_base64(encrypted);
-
-    masterKey = sodium.from_base64(masterKey, sodium.base64_variants.ORIGINAL);
-    let nonce = sodium.randombytes_buf(24);
-
-    const pk = sodium.crypto_secretbox_easy(
-      keyPair.privateKey,
-      nonce,
-      masterKey
-    );
-
-    nonce = sodium.to_base64(nonce);
-
-    const securedPrivateKey = sodium.to_base64(pk);
-    const publicKey = sodium.to_base64(keyPair.publicKey);
-
-    return {
-      str,
-      nonce,
-      publicKey,
-      securedPrivateKey,
-    };
-  } catch (error) {
-    console.log(error.message);
-    throw new AppError("Error while encrypting");
-  }
-};
-
-// unSeal
-const unSeal = async (str, nonce, publicKey, securedPrivateKey, masterKey) => {
-  try {
-    if (!str || !nonce || !publicKey || !securedPrivateKey)
-      throw new AppError(
-        "Str, nonce, public key and secured private key are required"
-      );
-
-    await sodium.ready;
-
-    masterKey = sodium.from_base64(masterKey, sodium.base64_variants.ORIGINAL);
-    nonce = sodium.from_base64(nonce);
-    securedPrivateKey = sodium.from_base64(securedPrivateKey);
-    publicKey = sodium.from_base64(publicKey);
-    str = sodium.from_base64(str);
-
-    const privateKey = sodium.crypto_secretbox_open_easy(
-      securedPrivateKey,
-      nonce,
-      masterKey
-    );
-
-    const decrypted = sodium.crypto_box_seal_open(str, publicKey, privateKey);
-    return sodium.to_string(decrypted);
-  } catch (error) {
-    console.log(error.message);
-    throw new AppError("Error while decrypting");
-  }
-};
-
-module.exports = {
-  hash,
-  verifyHash,
-  generateMasterKey,
-  generateJWTSecret,
-  seal,
-  unSeal,
-};

package/dist/cjs/utils/successResponse.cjs

@@ -1,13 +0,0 @@
-// success response to client
-const successResponse = (res, data, status) => {
-  const response = { success: true };
-
-  if (data) {
-    response.data = data;
-  }
-
-  res.status(status).json(response);
-};
-
-// export
-module.exports = successResponse;

package/dist/js/db.js

@@ -1,19 +0,0 @@
-// module imports
-import mongoose from "mongoose";
-
-import AppLog from "./utils/AppLog.js";
-
-// connecting to db
-const connectDB = async (uri, db) => {
-  const mongodbUri = uri || "mongodb://localhost:27017";
-  try {
-    AppLog("check", "db.js", "Connected successfully!");
-    return await mongoose.connect(`${mongodbUri}/${db || "test"}`);
-  } catch (error) {
-    AppLog("X", "db.js", "Error while connecting!");
-    AppLog("X", "db.js", error.message);
-  }
-};
-
-// export
-export default connectDB;