DEV Community: Izuchukwu Alaneme

Stop Rewriting the Same Node Utilities — I Built nodecore-kit Instead

Izuchukwu Alaneme — Sun, 15 Mar 2026 12:01:03 +0000

If you build backend applications with Node.js regularly, you’ve probably noticed a pattern.

Every new project seems to require the same set of utilities:
Error classes
JWT helpers
Logging utilities

And most of the time, developers end up copy-pasting the same code from previous projects.
I’ve done this more times than I can count.
After repeating this process across several projects, I decided to stop rewriting the same utilities and instead package them into a reusable toolkit.
That’s how nodecore-kit was born.

What is nodecore-kit?

nodecore-kit is a lightweight utility toolkit designed to simplify backend development in Node.js applications.

Instead of recreating common backend helpers in every project, you can install one package and get access to a collection of reusable utilities designed for modern backend workflows.

The goal is simple:

Reduce boilerplate and keep your backend code clean and consistent.

Why I Built It

While working on multiple backend services, I noticed the same problems:

Utilities scattered across projects
Slightly different implementations of the same logic
Rewriting helper functions every time a new project starts

For example, almost every project needed:

Custom error handling
JWT token utilities
Logging helpers Instead of copying these utilities from one repository to another, I decided to centralize them in a single reusable package. This also helps maintain consistency across different services and codebases.

Installation

You can install nodecore-kit from npm:

npm install nodecore-kit

or with yarn:

yarn add nodecore-kit

Example Usage

Here are a few examples of how nodecore-kit can simplify common backend tasks.

jwt helpers:

import { jwtService } from "nodecore-kit";

// Encode
const token = await jwtService.encode({
  data: { userId: 123, role: "admin" },
  secretKey: process.env.JWT_SECRET!,
  expiresIn: "7d",
});

// Decode + verify
const payload = await jwtService.decode<{ userId: number }>({
  token,
  secretKey: process.env.JWT_SECRET!,
});

Joi Validation:

import Joi from "joi";
import {joiMiddleware, joiValidate } from "nodecore-kit"l
const createUserSchema = Joi.object({
  name:  Joi.string().required(),
  email: Joi.string().email().required(),
});

// As Express middleware
router.post(
  "/users",
  joiMiddleware({
    body:   { schema: createUserSchema },
    params: { schema: Joi.object({ id: Joi.string().uuid().required() }) },
    query:  { schema: paginationSchema, options: { allowUnknown: true } },
  }),
  createUser,
);

Http and async utilites:

import {makeRequest, sleep, retry } from nodecore-kit;

// Simple GET
const user = await makeRequest<User>({ url: "/api/users/1" });

// POST with typed body
const post = await makeRequest<Post, CreatePostDto>({
  url: "/api/posts",
  method: "POST",
  data: { title: "Hello", body: "World" },
  token: "my-jwt-token",
});

// With retry + timeout
const data = await makeRequest<Data>({
  url: "/api/slow-endpoint",
  timeout: 5000,
  retries: 3,
});

Also nodecore-kit also include some popular infras like redis, sqs, s3 etc. Making it easy to simply plug and play.

import { SQS, S3, Redis } from "nodecore-kit";

const redis = new Redis("redis://localhost:6379");
await redis.start();

// Core ops
await redis.set("key", { foo: "bar" });
await redis.setEx("key", { foo: "bar" }, "1 hour");
const value = await redis.get<MyType>("key");
await redis.delete("key");

SQS

const sqs = new SQS({
  region: "us-east-1",
  accessKeyId: process.env.AWS_KEY!,
  secretAccessKey: process.env.AWS_SECRET!,
});

 // Enqueue
await sqs.enqueue({
  queueUrl: "https://sqs.us-east-1.amazonaws.com/1234/my-queue",
  message: { event: "user.created", userId: 1 },
});

sqs.dequeue({
  queueUrl: "https://sqs.us-east-1.amazonaws.com/1234/my-queue",
  consumerFunction: async (message) => {
    await processMessage(message);
  },
  dlqUrl: "https://sqs.us-east-1.amazonaws.com/1234/my-dead-letter-queue",
  useRedrivePolicy: false,
});

When Should You Use nodecore-kit?

You might find nodecore-kit useful if you:

Build Node.js APIs frequently
Want consistent utilities across projects
Prefer cleaner backend code with less boilerplate
Work on microservices or multiple backend services Instead of rewriting the same helper functions repeatedly, you can rely on a centralized toolkit.

The Goal

The goal of nodecore-kit isn’t to replace frameworks.
It’s simply to provide small, practical utilities that most backend projects need. Think of it as a developer toolkit for common backend patterns.

Feedback and Contributions

I’m actively improving nodecore-kit and would love feedback from other developers.
If you find it useful, feel free to:
⭐ Star the repository
🐛 Report issues
🔧 Submit pull requests

Open source tools get better through collaboration.

Check it out
Github repo:

Rockhillz / nodeCore-kit

A utility for nodejs developers

nodecore-kit

A modular backend SDK for Node.js services.

Provides infrastructure helpers, utilities, and microservice building blocks in a clean, scalable, and framework-agnostic way.

View on npm

📦 Features

Infrastructure

Redis — get/set/expire, scan, hash ops, auth cache helpers
SQS — enqueue, long-poll dequeue, DLQ support, graceful stop
S3 — upload, download, stream, copy, signed URLs
Cron — job scheduler with human-readable shorthands, overlap protection, per-job status tracking, and graceful shutdown
Mailer — provider-agnostic email adapter with SMTP, Resend, and SendGrid support
(Future: Kafka, etc.)

HTTP Utilities

makeRequest — typed, generic fetch wrapper with retry and timeout
Pagination helpers

Core Utilities

uuid — binary/string conversion, generation, FIFO support, validation
String utilities — camelCase, snakeCase, kebabCase, pascalCase, truncate, maskString, and more
Validator utilities — isEmail, isURL, isUUID, isEmpty, isNil, and more
Object utilities — flattenObject, unflattenObject
Async utilities — sleep…

View on GitHub

npm library: https://www.npmjs.com/package/nodecore-kit

Final Thoughts

Building backend services often involves repeating the same patterns over and over again.
Creating nodecore-kit helped me eliminate a lot of repetitive setup work and focus more on building actual application logic. If you also find yourself rewriting the same utilities across projects, a small toolkit like this might save you some time.

Happy coding 🚀

How to Generate a Secure JWT Secret Using Node.js

Izuchukwu Alaneme — Wed, 08 Jan 2025 08:51:05 +0000

When working with JSON Web Tokens (JWT) in your applications, ensuring that your secret key is strong and secure is crucial. A secure JWT secret helps protect your application from unauthorized access and ensures the integrity of your data. In this article, we will walk you through a simple method to generate a random, secure JWT secret using Node.js.

Why Use a Secure JWT Secret?

The JWT secret is used to sign and verify tokens in your application. If the secret is weak or predictable, attackers could forge tokens and gain unauthorized access to your application. This is why it’s essential to use a strong, randomly generated secret.

Generating a Secure JWT Secret

Node.js provides a built-in crypto module that allows us to generate secure random data. To generate a 256-bit (32-byte) JWT secret, use the following command in your terminal:

node -e "console.log(require('crypto').randomBytes(32).toString('hex'))"

What This Command Does:

require('crypto'): Imports the crypto module, which provides cryptographic functionalities.
randomBytes(32): Generates 32 random bytes of data (256 bits).
.toString('hex'): Converts the random bytes into a hexadecimal string, which is easier to store and use as a secret.

Example Output
Running the above command will generate a secure JWT secret similar to this:
e3ff5f077839c1331b1d893a728246685cb7dba9e3a77bffe7d52eaccf660988
This 64-character hexadecimal string is your randomly generated secret key. Use it in your application to sign and verify JWTs

How to Use the JWT Secret

Once you have your secret, you can store it in your environment variables for security purposes. For example, in a .env file:

JWT_SECRET=e3ff5f077839c1331b1d893a728246685cb7dba9e3a77bffe7d52eaccf660988

Then, in your application, you can access the secret like this:

require('dotenv').config();
const jwt = require('jsonwebtoken');

const token = jwt.sign({ userId: 123 }, process.env.JWT_SECRET, { expiresIn: '1h' });
console.log(token);

Final Thoughts

Generating a secure JWT secret is a critical step in securing your application. By using the crypto module in Node.js, you can easily generate a strong secret and ensure your tokens are well-protected. Remember to keep your secret safe by storing it in environment variables and never exposing it in your code repository.

Javascript is HARD (with ES6 madness)

Izuchukwu Alaneme — Thu, 26 Sep 2024 21:50:15 +0000

This will be a long read but Let me say it again.
JAVASCRIPT is hard. last we met, i was stepping into the world of Javascript, bright-eyed, hopeful coder stepping into the wild jungle saying "How hard could it be?". How wrong i was😂😂. It got harder, I'm surviving (barely), here's a little chaotic story about my journey.

Variables: beginning of madness
Variables are containers that holds values, where you store or manipulate data. I mean, why do we have 3 ways to create them: var, let, and const? why? laugh in ES6.
var: They said var is a loose cannon. like playing a game of chance. Don't go near it.
let: Great for variables that can change. Easier to manage.
Const: is for values that stay the same. immovable. Ohh — const doesn't mean the value can’t change, it just means you can’t reassign it.
Note: ECMAScript 2015 or ES6 was the second major revision to JavaScript.
Ooh, we said goodbye to String Concatenation, Hello Template Literals. With Template literals You can now use backticks and embed variables easily with ${}. Life became a little easier here, but figuring out when to use backticks vs quotes? Another mind-bender.

// Good old concat
const message = "Hi, " + name + ". You are " + age + " years old.";
// Template literal
const message = `Hi, ${name}! You are ${age} years old.`;

Functions: AKA Mr. Reusability, Mr. Maintainability...
A Function is a set of statement that performs a task. Consists of the function keyword, function name, parameter or not, Js statement in curly bracket.

function greet() {
  console.log("Hello, fellow strugglers😎!");
}

They seemed simple at first: encapsulate some logic, call it (i say invoke it), and boom! You’re coding.
Then ES6 said "This is arrow functions, use it". Arrow functions look simple, right? Just a short way to write functions. Took a while i got the syntax.

const greet = () => {
   console.log("Hello, fellow strugglers😎!");
}

Loops: Dancing with the Infinite.
The Many Ways to Suffer. Loops can execute a block of code a number of times. They are handy, if you want to run the same code over and over again, each time with a different value. They are many:
1. While Loop: keeps looping as long as the condition is true. Evil. and I'm not talking about its cousin, do-while.
2. for Loop: Good old for loop, my man. the trusty for loop. So familiar. So safe and So full of potential to throw infinite loops when you forget to increment a variable.
3. forEach: which is like the for loop’s cooler, more hipster cousin. It doesn’t need counters, doesn't take me to infinite. my man.
4. & 5. for..in and for..of: One’s great for looping over objects, the other is meant for iterating over arrays. I keep mixing them up and i learn through pain. still learning.

//for loop
for (let i = 0; i < 10; i++) {
  console.log(i); // Simple. Right? RIGHT?!
}

// forEach
let numbers = [1, 2, 3, 4, 5];
numbers.forEach(num => console.log(num));

Arrays: The list that keeps hunting
Arrays started out so promisingly. A simple list of items. Push things in, pull things out. Easy, right?

let shoppingList = ["apples", "bananas", "chocolate"];
shoppingList.push("ice cream");
console.log(shoppingList); // ['apples', 'bananas', 'chocolate', 'ice cream']

Enter filter, map, and find and the rest of the array method gang. My brain hasn’t been the same since.
The filter() method creates a new array filled with elements that pass a test provided by a function.
The find() method returns the value of the first element that passes a test. Array methods are so many, i need documentation for each😉, i mean there's length, splice, slice, join, pop, push, unshift, shift, map.., lets stop here.

let numbers = [1, 2, 3, 4, 5];
let evenNumbers = numbers.filter(num => num % 2 === 0);
console.log(evenNumbers); // [2, 4]

Objects: The Confusing Cousin of Arrays
Then came objects. Objects are kind of like arrays, but with keys and value. I was like, “Cool, I can handle this.” But then JavaScript threw in methods, and suddenly objects were doing things on their own. And then array of objects entered the equation. Accessing properties I'm either using dot notation or bracket notation. And don't get me started with .this

//Without method
let shoppingCart = {
  apples: 3,
  bananas: 2,
  chocolate: 1
};
// with method
let cart = {
  items: ["apple", "banana"],
  addItem(item) {
    this.items.push(item);
  }
};
cart.addItem("chocolate");
console.log(cart.items); // ['apple', 'banana', 'chocolate']

DOM Manipulation: Where the Real Struggles Began
Once I felt confident with arrays and objects, I thought, “Time to manipulate the DOM! I’m practically a web developer now!” You know nothing, Ygritte famously said.
This should be easy, i said again. Just grab an element and change it. If its an ID, getElementbyId is there for me. A class getElementsbyClassName is also there or queryselector and the one with All its brother.
And then there’s this whole addEventListener business. Sure, it works, but sometimes, events seem to fire off like they have a mind of their own.
Then i tried creating a shopping cart. Took me days and lots of SOS signal to my learned colleagues. Here I'm appendChild, removingChild, creatingElements, grabbing elements, setting attributes, styling, calling functions upon functions.
Then boldly added a mock database; me and array manipulation again. I'm accessing, I'm pushing, I'm finding, I'm tired (gets up again).

Imports and Exports: Boldly sharing the Madness😂🤣
At some point, I had written so much JavaScript that I needed to modularize my code. Enter import and export.

Copy code
// module.js
export function greet() {
  console.log("Hello from the module!");
}

// main.js
import { greet } from './module.js';
greet();

I thought breaking my code into smaller pieces would make it easier. Little did I know, I would end up importing a mountain of confusion.

Now I'm about to start Object-Oriented Programming (OOP) sounds fancy, But let me enjoy my weekend first before i get lost again.
Thanks for staying till the end. The goal still remains 1% better everyday. #ES6 #CodingStruggles #WebDevelopment #JavaScriptMadness #ProgrammingHumor #LearnToCode #WebDevelopment #HTML #CSS #ResponsiveDesign #CodingJourney

An update on my learning!

Izuchukwu Alaneme — Mon, 09 Sep 2024 20:17:03 +0000

🚀 It's been almost a week since I last shared my journey in web development, and I've made some exciting progress!
Last week we touched CSS frameworks. Bootstrap and tailwind.
Let me give you a quick rundown; Bootstrap offers a grid layout and pre-designed components, making it easy and faster to create responsive designs. Tailwind provides more flexibility with utility classes, helping to style elements quickly without writing custom CSS(still finding my way round tailwind). Now over the week, i completed three projects and they are all responsive🎉🥳:
1) An E-commerce Website using Bootstrap – diving deep into its responsive grid system and components. Really proud of this one.

2) A Blog with Tailwind CSS – still need more work. Kind of having a little hard time with tailwind CSS, but this too shall pass😁😊

3) My Portfolio Website – crafted with pure CSS (and just a touch of Bootstrap(containers class)). A work in progress.

Today i started javascript to add functionalities to the webpages(fingers crossed 😂).
The goal still remain the same: 1% better everyday.
criticisms and questions can come in the comment section. Thanks

🧩💻 #CodeNewbie #HTML #WebDevelopment #TechJourney #Programming #100DaysOfCode #DeveloperCommunity

Designed a 404 page

Izuchukwu Alaneme — Mon, 26 Aug 2024 20:05:39 +0000

Today i designed a 404 error page! Built the structure in HTML and styled it with CSS. And also made it fully responsive using @media queries, so it looks great on mobile. Learning and improving every day! The goal: 1% better everyday 💻 #WebDevelopment #HTML #CSS #ResponsiveDesign #CodingJourney

Learning CSS: My First Steps in Styling Web Pages

Izuchukwu Alaneme — Wed, 21 Aug 2024 19:40:35 +0000

Between Monday and today, I took a significant step forward by diving deeper into CSS, a styling language that breathe into web pages. 🌐

Started by learning the essentials—selectors, code blocks, declarations, and their values. It was exciting to see how a few lines of code could transform plain HTML into something visually appealing. In CSS, styling can be achieved in three ways: Inline styling (by adding the style attribute in the opening tag), Internal styling (by adding the style element in the head section) and lastly, external styling (by creating a .css file and linking it to the .html file). Now for best practice, we're to use external styling.🎨

By linking an external stylesheet to our HTML, we were able to apply consistent styles across multiple pages. I experimented with different colors, font types, borders, and margins,paddings and even apply colors to pseudo-class.

We also explored how to target various containers on the page using IDs and classes. By assigning IDs for unique elements and classes for groups of similar elements, I was able to style sections with precision. This method allowed me to create a clean, organized layout, with each part of the page styled exactly as I envisioned.

I’m excited to keep pushing forward, learning more, and sharing my progress with you all and becoming. My goal is to be at least 1% better everyday (small right. I know). The journey has just begun, and there’s so much more to create!

CodeNewbie #CSS #WebDevelopment #TechJourney #CodingLife #LearnToCode

Building Web Pages Step by Step: Exploring Structure and Elements in HTML

Izuchukwu Alaneme — Wed, 14 Aug 2024 19:11:47 +0000

🌟 Today marks a key step in my software development journey! 🚀 I wrote my first lines of code, diving into the essentials of HTML. Covered elements and tags. Yesterday, I explored the boxing technique to structure websites, and today I put it into practice by creating sections like headers, footers, and content areas. I also added various HTML elements, including image elements and link elements, and even tried my hand at inner linking on a single-page website. It’s amazing to see how these pieces fit together to build a functional and organized webpage. Can’t wait to keep learning and creating! 💻🛠️ #CodeNewbie #WebDevelopment #HTML #CSS #LearningToCode

Started Learning Software Development

Izuchukwu Alaneme — Tue, 13 Aug 2024 18:52:06 +0000

Started my software development journey and I'm here to document my journey.

started learning about Git and Github. Using basic Git command lines to run task like creating a repository, making branches etc. and then pushing to the remote environment, Github. Also learnt about the Github workflow
Today, i dived into html. No coding yet. but learnt the basic principle of designing a responsive website, which is boxing. now boxing is a way of breaking down a website design into manageable sections, each represented as a "box." These boxes correspond to different parts of the website's layout, such as headers, footers, sidebars, or content areas. This approach makes it easier to structure the site and style it with CSS. we do this by starting the box from outside to inside. its like building a house! 🧩💻 #CodeNewbie #HTML #WebDevelopment #TechJourney #Programming #100DaysOfCode #DeveloperCommunity