DEV Community: Avinash

TypeForge-ts: Advanced TypeScript Utility Types (DeepPartial, Flatten, Paths)

Avinash — Fri, 03 Apr 2026 16:44:32 +0000

TypeScript's built-in utility types are great, but they don't go deep enough for real-world complex types. TypeForge-ts fills the gap with advanced type-level utilities that save hundreds of lines of boilerplate.

What is TypeForge-ts?

A zero-dependency TypeScript utility type library with deep transformations, path inference, conditional utilities, and more.

npm install typeforge-ts
bun add typeforge-ts

DeepPartial & DeepRequired

import type { DeepPartial, DeepRequired } from 'typeforge-ts';

type Config = {
  server: { host: string; port: number };
  db: { url: string; pool: { min: number; max: number } };
};

type PartialConfig = DeepPartial<Config>;
// Every nested field becomes optional recursively!

type FullConfig = DeepRequired<Config>;
// Every nested field becomes required!

Paths & PathValue

import type { Paths, PathValue } from 'typeforge-ts';

type User = { id: number; profile: { name: string; avatar: { url: string } } };

type UserPaths = Paths<User>;
// 'id' | 'profile' | 'profile.name' | 'profile.avatar.url'

type NameType = PathValue<User, 'profile.name'>; // string

function get<T, P extends Paths<T>>(obj: T, path: P): PathValue<T, P> {
  // Type-safe nested getter!
}

Flatten

import type { Flatten } from 'typeforge-ts';

type Nested = { a: { b: { c: string } } };
type Flat = Flatten<Nested>; // { 'a.b.c': string }

Why TypeForge-ts?

Zero dependencies
Zero runtime cost (type-level only)
Works with TypeScript 4.7+
Tree-shakeable

GitHub: https://github.com/Avinashvelu03/TypeForge-ts

What TypeScript utility types do you write over and over? Let's discuss!

mathfuse: TypeScript Math Utilities (Statistics, Vectors, Matrices) Zero Dependencies

Avinash — Fri, 03 Apr 2026 16:41:49 +0000

Tired of pulling in huge math libraries just to compute a mean or dot product? mathfuse gives you a lean, tree-shakeable TypeScript math toolkit with zero dependencies.

What is mathfuse?

A collection of typed math utilities covering statistics, vectors, matrices, and more.

npm install mathfuse
bun add mathfuse

Statistics

import { mean, median, stddev, percentile } from 'mathfuse';

const data = [2, 4, 4, 4, 5, 5, 7, 9];
console.log(mean(data));           // 5
console.log(median(data));         // 4.5
console.log(stddev(data));         // 2
console.log(percentile(data, 75)); // 6

Vectors

import { dot, magnitude, normalize } from 'mathfuse';

const v1 = [1, 2, 3];
const v2 = [4, 5, 6];
console.log(dot(v1, v2));      // 32
console.log(magnitude(v1));    // 3.74
console.log(normalize(v1));    // [0.27, 0.53, 0.80]

Matrices

import { matmul, transpose, determinant } from 'mathfuse';

const A = [[1, 2], [3, 4]];
console.log(matmul(A, [[5,6],[7,8]])); // [[19,22],[43,50]]
console.log(determinant(A));           // -2

Why mathfuse?

Zero dependencies
Full TypeScript generics
Tree-shakeable ESM/CJS
Works everywhere (Node.js, Bun, Deno, browsers)

GitHub: https://github.com/Avinashvelu03/mathfuse

What math functions do you wish were easier in TypeScript? Let me know!

ultraenv: Type-Safe Environment Variables for TypeScript (Validated at Startup)

Avinash — Fri, 03 Apr 2026 16:38:19 +0000

How many times have you deployed to production only to get a runtime crash because process.env.DATABASE_URL was undefined? ultraenv eliminates that entire class of bug.

What is ultraenv?

A TypeScript-first environment variable manager that validates all your env vars at application startup.

npm install ultraenv
bun add ultraenv

The Problem

// Without ultraenv - crashes at runtime in production!
const db = new Database(process.env.DATABASE_URL); // Could be undefined!

The Solution

import { defineEnv } from 'ultraenv';

const env = defineEnv({
  DATABASE_URL: { type: 'string', required: true },
  PORT: { type: 'number', default: 3000 },
  NODE_ENV: { type: 'enum', values: ['development', 'production', 'test'] },
  API_SECRET: { type: 'string', required: true, secret: true }
});

// All vars are fully typed and guaranteed!
const db = new Database(env.DATABASE_URL); // string!
const port = env.PORT; // number!

Features

Startup validation with clear error messages
Automatic type coercion (string to number/boolean)
Secret masking in logs
Zero dependencies
Works with Node.js, Bun, Deno, Docker, Vercel

GitHub: https://github.com/Avinashvelu03/ultraenv

What's your biggest env var horror story? Share below!

valicore: Runtime Type Validation for TypeScript (Schemas, Guards, Parsing)

Avinash — Fri, 03 Apr 2026 16:36:06 +0000

TypeScript is great for catching type errors at compile time — but what about runtime? External API responses, form data, env vars — they're all untyped at runtime. valicore fixes that.

What is valicore?

A zero-dependency TypeScript validation library with full schema inference, type guards, and safe parsing.

npm install valicore
bun add valicore

Core Features

Schema Definition

import { v } from 'valicore';

const UserSchema = v.object({
  id: v.number(),
  name: v.string().min(1).max(100),
  email: v.string().email(),
  role: v.enum(['admin', 'user', 'guest']),
  createdAt: v.date().optional()
});

type User = v.infer<typeof UserSchema>;
// Automatically inferred TypeScript type!

Safe Parsing

const result = UserSchema.safeParse(apiResponse);

if (result.success) {
  console.log(result.data.email); // Fully typed!
} else {
  console.error(result.errors); // Detailed error messages
}

Type Guards

if (UserSchema.is(data)) {
  // data is narrowed to User type here
  sendWelcomeEmail(data.email);
}

Nested Schemas

const OrderSchema = v.object({
  id: v.string().uuid(),
  user: UserSchema,
  items: v.array(v.object({
    productId: v.string(),
    quantity: v.number().int().positive()
  })),
  total: v.number().positive()
});

Why valicore?

Zero dependencies
Automatic TypeScript type inference
Detailed, human-readable error messages
Composable and reusable schemas
Works with Node.js, Bun, Deno, and browsers

Install

npm install valicore

GitHub: https://github.com/Avinashvelu03/valicore

How do you handle runtime validation in your TypeScript projects? Drop your approach in the comments!

flowx-control: TypeScript Flow Control (Debounce, Throttle, RateLimit) for Modern Apps

Avinash — Fri, 03 Apr 2026 16:34:14 +0000

Ever struggled with UI freezing on every keystroke or APIs getting hammered with duplicate calls? flowx-control solves exactly that.

What is flowx-control?

A zero-dependency TypeScript library that gives you precise control over function execution timing. Debounce, throttle, rate-limit, and more — all type-safe and tree-shakeable.

npm install flowx-control
bun add flowx-control

Core Features

Debounce

Delay execution until after calls stop:

import { debounce } from 'flowx-control';

const search = debounce(async (query: string) => {
  const results = await api.search(query);
  updateUI(results);
}, 300);

// Only fires 300ms after user stops typing
input.addEventListener('input', (e) => search(e.target.value));

Throttle

Limit execution to once per interval:

import { throttle } from 'flowx-control';

const onScroll = throttle(() => {
  updateScrollPosition();
}, 100);

window.addEventListener('scroll', onScroll);

Rate Limit

Control how many calls per time window:

import { rateLimit } from 'flowx-control';

const apiCall = rateLimit(fetchData, {
  maxCalls: 10,
  windowMs: 1000 // 10 calls per second
});

Once

Execute only on first call:

import { once } from 'flowx-control';

const init = once(() => {
  setupDatabase();
  loadConfig();
});

init(); // runs
init(); // skipped

Why flowx-control?

Zero dependencies
Full TypeScript support with generics
Works in Node.js, Bun, Deno, browsers, and edge runtimes
Tiny bundle size
Cancellable and flushable debounces

Works Everywhere

Tree-shakeable, dual ESM/CJS output. Drop it into any modern stack.

GitHub: https://github.com/Avinashvelu03/flowx-control

What flow control patterns do you use in your TypeScript projects?

flowshield: TypeScript Resilience Library (Circuit Breaker, Retry, Timeout) for Edge Runtimes

Avinash — Fri, 03 Apr 2026 16:29:52 +0000

Why Resilience Matters in Production

Every distributed system fails eventually. APIs time out, databases get overloaded, third-party services go down. Without resilience patterns, one failing dependency can cascade into a full system outage.

flowshield is a zero-dependency TypeScript-first resilience library that gives you composable fault-tolerance policies for any async operation.

GitHub: https://github.com/Avinashvelu03/flowshield
npm: npm install flowshield

What's Inside

Retry with Exponential Backoff

import { retry } from 'flowshield';

const result = await retry(
  () => fetchFromAPI(),
  { attempts: 3, backoff: 'exponential', baseDelay: 100 }
);

Circuit Breaker

Automatically stops calling a failing service and recovers when it's healthy:

import { circuitBreaker } from 'flowshield';

const breaker = circuitBreaker({
  threshold: 5,        // open after 5 failures
  timeout: 30_000,     // try again after 30s
  halfOpenRequests: 2  // test with 2 requests
});

const result = await breaker.execute(() => callExternalService());

Timeout

import { timeout } from 'flowshield';

const result = await timeout(
  () => slowOperation(),
  { ms: 3000 } // cancel if takes more than 3s
);

Composable Policies

import { wrap, retry, circuitBreaker, timeout, fallback } from 'flowshield';

const resilientFetch = wrap(
  retry({ attempts: 3 }),
  circuitBreaker({ threshold: 5 }),
  timeout({ ms: 3000 }),
  fallback({ value: cachedData })
);

const data = await resilientFetch(() => fetchData());

Other Policies

Hedge — race multiple attempts, take the fastest response
Cache — built-in memoization with TTL
Bulkhead — limit concurrency to protect downstream

Works Everywhere

Tree-shakeable, dual ESM/CJS, zero dependencies. Runs on Node.js, Bun, Deno, and Cloudflare Workers.

npm install flowshield
bun add flowshield

GitHub: https://github.com/Avinashvelu03/flowshield

What resilience patterns do you use in production? Would love to hear your thoughts!

guarden: Zero-Dependency TypeScript Runtime Safety (Type Guards, Result/Option Monads)

Avinash — Fri, 03 Apr 2026 16:27:50 +0000

The Problem with TypeScript Runtime Safety

TypeScript gives you compile-time type checking, but at runtime you have zero protection. API responses come back as unknown, JSON.parse() returns any, and one wrong assumption crashes production.

const data = JSON.parse(rawInput); // any - no safety
const user = data.user; // could be anything
user.name.toUpperCase(); // TypeError: Cannot read property 'toUpperCase' of undefined

Introducing guarden

guarden is a zero-dependency TypeScript-first runtime safety toolkit that closes the gap between compile-time and runtime type safety.

GitHub: https://github.com/Avinashvelu03/guarden
npm: npm install guarden

Key Features

1. 60+ Type Guards with Auto-Narrowing

import { isString, isValidEmail, isUUID, isNonEmptyArray, isISO8601Date } from 'guarden';

if (isString(value)) {
  // TypeScript narrows: value is string here
  console.log(value.toUpperCase()); // safe!
}

const emails = data.filter(isValidEmail);
// TypeScript infers: emails is string[]

2. Result and Option Monads

No more try/catch spaghetti. Handle errors as values:

import { Result, Option } from 'guarden';

const result = Result.try(() => JSON.parse(rawInput));

result
  .map(data => data.users)
  .filter(isNonEmptyArray)
  .match({
    ok: (users) => renderUsers(users),
    err: (error) => showError(error.message),
  });

3. Composable Pipelines

import { pipe } from 'guarden';

const processUser = pipe(
  (input: unknown) => Result.try(() => JSON.parse(input as string)),
  (r) => r.map(d => d.user),
  (r) => r.flatMap(u => isString(u.name) ? Result.ok(u) : Result.err('Invalid user'))
);

4. Assertions and Invariants

import { assert, invariant } from 'guarden';

assert(isString(name), 'Name must be a string');
invariant(age >= 0 && age <= 150, `Invalid age: ${age}`);

Stats

313 tests, 100% coverage
Zero dependencies
Tree-shakeable (only import what you use)
Dual ESM/CJS build
Node.js, Bun, Deno, Cloudflare Workers

Installation

npm install guarden
bun add guarden

Check out the full docs on GitHub: https://github.com/Avinashvelu03/guarden

Would love your feedback especially on the monad API design!