Aura

The High-Performance API Scaffolder.
Aura is an interactive CLI designed for developers who want to build modern Express.js backends—without the boilerplate. It abstracts framework complexities into a dedicated core while giving you total control over the features you need.

Why Aura?

• Zero Boilerplate: Skip the setup. Get a production-ready API in 30 seconds.
• Abstraction-First: Your logic in src/routes, framework magic in src/base.
• Full-Type Safety: Built from the ground up with TypeScript and Zod.
• Enterprise-Ready: Built-in support for OpenTelemetry, Redis, Auth, and Inngest.

Quick Start

Start your next project immediately with npx:

npx @ahmadjavaiddev/aura my-new-project

Options

| Command | Description | | :--- | :--- | | aura [name] | Create a new project in the specified directory | | aura add [feature] | Inject a new feature (e.g. redis, prisma) into an existing Aura project | | -v, --version | Display current Aura version | | -h, --help | Show usage information |

Pick Your Stack

Aura is modular by design. Select only the components you need for your project:

Database & Models

• ORM Options: Prisma (PostgreSQL), Drizzle (SQL), Mongoose (MongoDB).
• Auto-Sync: Pre-configured scripts for database migrations and client generation.

Security & Auth

• Providers: Clerk (Hosted), Better-Auth (Self-hosted), Custom JWT.
• Protection: Optional Redis-based Rate Limiting and Role-based access skeletons.

Performance & Scaling

• Caching: Choose between local In-memory or distributed Redis caching.
• Background Jobs: Native Inngest support for event-driven background functions.

Observability & Tooling

• Logging: Console-based or OpenTelemetry + PostHog for production tracking.
• Development: Choice of Biome (Ultra-fast) or ESLint + Prettier.
• Email: Integrated Resend or traditional SMTP (Nodemailer).

Infrastructure

• Docker: Automatically generate a production-ready Dockerfile and docker-compose.yml.
• CI/CD: Generate GitHub Actions workflows for seamless testing and linting pipelines.

⚡ Aura Add

Scaffolded a barebones project but decided you need Redis later? Use the aura add command to intelligently inject features into your existing project—modifying package.json, updating environment variables, injecting imports, and setting up initializations automatically using slot markers!

aura add redis
aura add prisma

The Aura Blueprint

The generated project structure is designed to isolate framework code from your business logic:

my-new-project/
├── src/
│   ├── app.ts              # Clean main entry point
│   ├── routes/             # YOUR LOGIC: API endpoints live here
│   ├── base/               # THE CORE: Framework abstractions (Internal)
│   ├── config/             # Environment & service configurations
│   ├── middlewares/        # Custom middlewares (Auth, Logger)
│   ├── utils/              # Shared utilities (Zod, Errors, Email)
│   └── ...                 # Feature directories (models, inngest, etc.)
├── .env                    # Pre-configured environment boilerplate
├── package.json
└── tsconfig.json

Defining Routes

Aura makes route definition declarative and type-safe using the defineRoute utility. Every route automatically returns a heavily standardized ApiResponse<T>:

import { defineRoute } from "../base/define-route";
import { z } from "zod";

export const createUser = defineRoute({
  method: "post",
  path: "/users",
  input: {
    body: z.object({ name: z.string(), email: z.string().email() })
  },
  output: z.object({ id: z.string(), name: z.string() }),
  handler: async ({ body }) => {
    // Body is fully typed!
    const { name, email } = body;
    // Return the output according to the schema - Aura automatically wraps it in a standard response:
    // { success: true, data: { ... }, metadata: { timestamp: "...", path: "/users" } }
    return { id: "123", name };
  },
});

Built by Ahmad Javaid