The Enterprise TypeScript Toolkit.

A curated suite of reusable production-ready packages and presets. Zero boilerplate, edge-compatible, and designed to scale from prototype to enterprise.

Get Started

src/lib/forgekit.ts

typescript

// 1. Initialize modular application layers
import { ForgeApp } from '@forgekit/core';
import { db } from '@forgekit/db';
import { auth } from '@forgekit/auth';

const app = new ForgeApp();

// 2. Connect DB transaction adapters
app.use(db({
  url: process.env.DATABASE_URL
}));

// 3. Bind OAuth2 / session identity modules
app.use(auth({
  session: { maxAge: '7d' }
}));

export default app;

Powering Next-Gen Engineering Teams

ACME

VERTEX

QUANTUM

APEX

CELESTIAL

Core Pillars

Architected for High-Growth Tech Stacks

Forget cobbling dependencies together. ForgeKit offers type-safe, performant layers that share a unified design standard.

Lightning Performance

Optimized compilations, zero runtime dependencies where it counts, and native support for serverless Cloudflare Workers and Vercel Edge.

Enterprise Security

Built-in security guidelines including automated CSRF protection, cryptographic session utilities, and strict CORS handler presets.

Zero Assertions Type-Safety

Deep TypeScript integrations ensuring compile-time validations. Throw away manual type casting and build with static definitions.

Ecosystem Catalog

Our Modular Toolkit Foundations

Every package is self-contained. Install only what you need. From identity management to database execution and logger frameworks.

Identity

@forgekit/auth

Full OAuth2/OpenID sessions, multi-factor tokens, and session databases integrated natively.

JWT/Session tokens
MFA Authenticator
OAuth adapter libraries

Storage

@forgekit/db

Dynamic schema transaction wrappers optimized for high-throughput Postgres, MySQL, or Cloudflare D1 databases.

Edge connection pools
Type-safe queries
Replica routing

Observability

@forgekit/logger

Zero-overhead structured JSON logger designed for Cloudwatch, Datadog, or Vercel logs.

Context hooks
JSON serialization
Log forwarding

DevOps

@forgekit/config

Type-safe environmental configurations with schema validations, dotenv mappings, and runtime validations.

Runtime schema assertions
Vault decrypt secrets
Type autocompletions

Live Code Bench

Code with Absolute Certainty

Use standard TypeScript interfaces to auto-complete session properties, databases schema tables, and contextual log mappings as you type.

End-to-End Type Safety

Edge Connector Optimization

// Initialize your enterprise app stack in minutes
import { ForgeApp } from '@forgekit/core';
import { db } from '@forgekit/db';
import { auth } from '@forgekit/auth';

const app = new ForgeApp();

// Bind database connection pools
app.use(db({
  url: process.env.DATABASE_URL,
  poolSize: 20
}));

// Bind session management
app.use(auth({
  session: { maxAge: '7d' },
  providers: ['github', 'google']
}));

export default app;

// Type-safe session query and access controls
import { auth } from '$lib/forgekit';

export const POST = async ({ request }) => {
  const session = await auth.getSession(request);

  if (!session) {
    return new Response('Unauthorized', { status: 401 });
  }

  // Session user object is fully typed
  const userRole = session.user.role; // Typed as 'admin' | 'user'
  
  return new Response(JSON.stringify({ 
    message: 'Authorized access for ' + userRole 
  }));
};

// Edge-optimized database transaction pools
import { db } from '$lib/forgekit';

export const load = async () => {
  // Queries are checked at compile time
  const users = await db.transaction(async (tx) => {
    return await tx.select('id', 'email')
      .from('users')
      .where('active', '=', true)
      .limit(10);
  });

  return { users };
};

Architectural Pattern

Unified Application Flow

Schema definitions at the database tier flow automatically into type safety parameters on client layouts.

1. Storage Layer

Define SQL schema or Cloudflare D1 tables matching strict type properties.

2. Server Middleware

ForgeKit validates route headers, authenticates tokens, and maps context.

3. Type-Safe View

Svelte components render native layout runes cleanly without runtime data mapping.

Release Timeline

Our Development Roadmap

We are rapidly building core enterprise packages. Track our progress, check off completed milestones, and submit requests on GitHub.

v1.0.0 Release (Stable)

Core CLI initializer, @forgekit/auth, and postgres-optimized @forgekit/db adapters.

Cloudflare Support

Full compatibility verification with Cloudflare D1 storage databases and Workers KV routing.

@forgekit/logger (Beta)

High-performance structured JSON logging utilities for real-time diagnostics.

@forgekit/email (Backlog)

SMTP email clients and templates for Resend, Sendgrid, and Mailgun API endpoints.

Build Enterprise TypeScript Apps Faster

Initialize a new app with the CLI in minutes and run on Vercel or Cloudflare with zero friction.

Get Started Now