@starklabs/backend-core 1.1.0 → 1.2.0

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.MONGO_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;