Introduction

Nuxt Auto is a collection of modules that dramatically accelerate full-stack development by automatically generating production-ready APIs and admin interfaces from your database schemas.

What is Nuxt Auto?

Nuxt Auto consists of two complementary Nuxt modules:

Nuxt Auto API

Auto-generate type-safe REST APIs from Drizzle ORM schemas

Define your database schema with Drizzle ORM and get complete CRUD endpoints automatically. No need to write repetitive route handlers, validation logic, or authorization checks manually.

Key capabilities:

• Automatic CRUD endpoint generation
• Deny-by-default authorization (operation, row, object and field level)
• Built-in validation with Zod
• Multi-database support (SQLite, Postgres, MySQL, D1, Turso, PlanetScale)
• Plugin system for extensibility
• Custom endpoints and handler overrides
• Cursor & offset pagination
• Soft delete support
• Multi-tenancy
• M2M relationships
• Lifecycle hooks

Nuxt Auto Admin

Beautiful admin panel generated from Auto API resources

Once your APIs are defined, Auto Admin automatically creates a complete admin interface with full CRUD operations, permissions, and customization options.

Key capabilities:

• Auto-generated CRUD pages (list, detail, create, edit)
• Permission-based access control
• Form widgets: text, textarea, number, checkbox, select, date/time, password, relation and multi-relation select
• M2M relationship management
• Custom pages for specialized admin functionality
• Fully customizable branding and theming
• Dark mode support
• Responsive design

Why Nuxt Auto?

Eliminate Boilerplate

Stop writing the same CRUD endpoints and admin interfaces over and over. Define your schema once, get everything else automatically.

Without Nuxt Auto:

// Manual API route
export default defineEventHandler(async (event) => {
  const id = getRouterParam(event, 'id')
  const body = await readBody(event)

  // Manual validation
  if (!body.email || !isValidEmail(body.email)) {
    throw createError({ statusCode: 400, message: 'Invalid email' })
  }

  // Manual authorization
  const user = await getUser(event)
  if (!user || user.role !== 'admin') {
    throw createError({ statusCode: 403, message: 'Forbidden' })
  }

  // Manual database query
  const result = await db.update(users)
    .set(body)
    .where(eq(users.id, id))
    .returning()

  return result[0]
})

With Nuxt Auto:

// Your schema IS your API…
export const users = sqliteTable('users', {
  id: integer('id').primaryKey({ autoIncrement: true }),
  email: text('email').notNull().unique(),
  name: text('name'),
  role: text('role', { enum: ['user', 'admin'] }).default('user'),
})

// …and you declare who may do what (anything undeclared is refused)
export const usersAuth: ResourceAuthConfig = {
  permissions: { read: ctx => !!ctx.user, update: 'admin', create: 'admin', delete: 'admin' },
}

Validation (from the schema), row filtering, pagination and the endpoints themselves come for free.

Type-Safe End-to-End

TypeScript throughout: typed config, auth rules and server context, and composables you type with your row types (useAutoApiList<Post>('posts')). Drizzle infers those row types from your schema (typeof posts.$inferSelect).

Production-Ready Features

Built-in authorization, validation, pagination, multi-tenancy, soft deletes, and more. All the features you need for production applications without writing them yourself.

Flexible & Extensible

Not a black box. Override any handler, add custom endpoints, create plugins, define custom validation, and build custom admin pages when needed.

Use Cases

Nuxt Auto is perfect for:

• SaaS applications - Multi-tenant data isolation, admin panels, user management
• Internal tools - Rapid development of CRUD interfaces for internal teams
• Content management - Blog posts, pages, media management
• Data dashboards - Admin interfaces for viewing and editing data
• MVP development - Ship faster with auto-generated APIs and admin UIs
• Monolithic applications - Full-stack Nuxt apps with database-driven features

Architecture

┌─────────────────────────────────────────┐
│         Nuxt Application                │
├─────────────────────────────────────────┤
│                                         │
│  Frontend (Auto-generated Composables)  │
│  • useAutoApiList()                     │
│  • useAutoApiMutation()                 │
│  • Admin UI Components                  │
│                                         │
├─────────────────────────────────────────┤
│                                         │
│  Auto API (REST Endpoints)              │
│  • GET /api/users                       │
│  • POST /api/users                      │
│  • PATCH /api/users/:id                 │
│  • DELETE /api/users/:id                │
│                                         │
├─────────────────────────────────────────┤
│                                         │
│  Drizzle ORM                            │
│  • Type-safe queries                    │
│  • Schema definitions                   │
│  • Migrations                           │
│                                         │
├─────────────────────────────────────────┤
│                                         │
│  Database                               │
│  • SQLite / Postgres / MySQL            │
│  • Cloudflare D1 / Turso / PlanetScale  │
│                                         │
└─────────────────────────────────────────┘

Next Steps

• Installation - Set up Nuxt Auto in your project
• Quick Start - Build your first API and admin panel
• Auto API Docs - Deep dive into API features
• Auto Admin Docs - Customize your admin panel