A powerful .NET tool designed to streamline backend API development by automatically generating controllers with CRUD endpoints for your entities. Build production-ready APIs in minutes, not hours.

1. Features
2. Prerequisites
3. Quick Start
4. Installation
5. Usage
   • CLI Commands
   • Source Generator
6. Examples
7. Configuration
8. Contributing

• Automatic CRUD Generation: Generate complete controllers with Create, Read, Update, Delete operations
• Advanced Filtering: Filter by any field with support for complex queries
• Built-in Pagination: Efficient pagination with customizable page sizes
• Flexible Sorting: Sort by any field in ascending or descending order
• Source Generator: Compile-time code generation for zero runtime overhead
• CLI Tool: Scaffold complete projects with a single command
• Angular UI: Modern web interface for content management (CCUI.Dappi)
• Headless CMS: Ready-to-use content management system
• PostgreSQL Support: Optimized for PostgreSQL databases
• RESTful APIs: Generate standards-compliant REST endpoints

Dappi consists of three main components working together to provide a complete API development solution:

• CLI Tool: Console application for project scaffolding and management
• Source Generator: Compile-time code generation for CRUD endpoints
• Headless CMS: Content management capabilities with UI components
• Generated API: Complete .NET API with controllers, entities, and migrations
• Angular UI (CCUI.Dappi): Modern web interface for content management and API interaction
• Swagger Integration: Automatic API documentation
• PostgreSQL Database: Optimized data persistence layer

• .NET 9.0 or later
• PostgreSQL database (for data persistence)

Get up and running with Dappi in under 5 minutes:

# Install the CLI tool
dotnet tool install --global Dappi.Cli --prerelease

# Create a new project
dappi init --name MyApi --path ./MyApi --use-prerelease

# Navigate to your project
cd MyApi

# Configure your database connection in appsettings.json
# Then start your API
dappi start

Note: Currently all Dappi packages are in preview. Once stable versions are released, you can omit the --prerelease flag.

dotnet tool install --global Dappi.Cli --prerelease

Add the source generator to your existing project:

<PackageReference Include="Dappi.SourceGenerator" Version="*-*">
  <PrivateAssets>all</PrivateAssets>
  <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
</PackageReference>

Or use the CLI:

dotnet add package Dappi.SourceGenerator --prerelease

dotnet add package Dappi.HeadlessCms --prerelease

The Headless CMS package provides additional content management capabilities for your Dappi-generated APIs.

Note: All packages are currently in preview. The --prerelease flag will be unnecessary once stable versions are available.

dappi init --name <PROJECT-NAME> --path <OUTPUT-DIRECTORY> --use-prerelease

Creates a new Dappi project with all necessary boilerplate code.

dappi start

Starts your API server with hot reload enabled.

Define your entities using the [CCController] attribute to automatically generate CRUD controllers:

using Dappi.SourceGenerator;

[CCController]
public class Book
{
    public int Id { get; set; }
    public string Title { get; set; }
    public string Author { get; set; }
    public DateTime PublishedDate { get; set; }
    public decimal Price { get; set; }
}

This automatically generates a controller accessible at /api/book/ with the following endpoints:

• GET /api/book - List all books (with filtering, pagination, sorting)
• GET /api/book/{id} - Get a specific book
• POST /api/book - Create a new book
• PUT /api/book/{id} - Update an existing book
• DELETE /api/book/{id} - Delete a book

[CCController]
public class Book
{
    public int Id { get; set; }
    public string Title { get; set; }
    public string Author { get; set; }
    public string ISBN { get; set; }
    public DateTime PublishedDate { get; set; }
    public decimal Price { get; set; }
    public bool IsAvailable { get; set; }
}

[CCController]
public class Product
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string Description { get; set; }
    public string SKU { get; set; }
    public decimal Price { get; set; }
    public int StockQuantity { get; set; }
    public string Category { get; set; }
    public string[] Tags { get; set; }
    public DateTime CreatedAt { get; set; }
    public DateTime UpdatedAt { get; set; }
}

# Get all books with pagination
GET /api/book?page=1&pageSize=10

# Filter books by author
GET /api/book?author=Tolkien

# Sort books by price (descending)
GET /api/book?sortBy=price&sortOrder=desc

# Create a new book
POST /api/book
{
  "title": "The Hobbit",
  "author": "J.R.R. Tolkien",
  "isbn": "978-0547928227",
  "publishedDate": "1937-09-21T00:00:00Z",
  "price": 12.99,
  "isAvailable": true
}

Configure your PostgreSQL connection in appsettings.json:

{
  "Dappi": {
    "PostgresConnection": "Host=localhost;Database=myapi;Username=postgres;Password=password"
  }
}

Filter by any property of your entity:

# Single filter
GET /api/book?author=Tolkien

# Multiple filters
GET /api/book?author=Tolkien&isAvailable=true

# Date range filtering
GET /api/book?publishedDate>=2020-01-01&publishedDate<=2023-12-31

Efficient pagination with customizable page sizes:

# Basic pagination
GET /api/book?page=1&pageSize=10

# Large result sets
GET /api/book?page=5&pageSize=50

Sort by any field in ascending or descending order:

# Sort by title (ascending)
GET /api/book?sortBy=title

# Sort by price (descending)
GET /api/book?sortBy=price&sortOrder=desc

# Multiple sort criteria
GET /api/book?sortBy=author,publishedDate&sortOrder=asc,desc

The CCUI.Dappi Angular project provides a modern web interface for managing your Dappi-generated APIs:

• Content Management: Intuitive interface for CRUD operations
• API Explorer: Interactive tool to test your generated endpoints
• Entity Management: Visual tools for managing your data models
• Real-time Updates: Live data synchronization with your API

To work with the Angular UI:

# Navigate to the Angular project
cd CCUI.Dappi

# Install dependencies
npm install

# Start development server
npm start

# Build for production
npm run build

We welcome contributions from the community! Whether you're fixing bugs, improving documentation, or adding new features, we appreciate your help.

Follow these steps to set up the project locally for development.

git clone https://github.com/codechem/dappi.git
cd dappi

Make sure you have the following installed on your machine:

• .NET SDK 9.0 or later
• PostgreSQL

  💡 Recommended: run PostgreSQL in a Docker container (see step 3)

• Node.js (only required for UI work)

  💡 Recommended Node.js version: 16+

To quickly set up a PostgreSQL instance using Docker, run:

docker run --name DappiPostgres -d \
  -p 5432:5432 \
  -e POSTGRES_PASSWORD=admin \
  -e POSTGRES_USER=postgres \
  postgres:alpine

This will:

• Start a PostgreSQL container named DappiPostgres
• Expose port 5432
• Set the password for the postgres user to admin

You can connect to this database using your app or a tool like DBeaver with:

• Host: localhost
• Port: 5432
• User: postgres
• Password: admin

Restore and build the .NET solution:

cd templates/MyCompany.MyProject.WebApi/
dotnet restore
dotnet build

Create migrations and update the database:

dotnet ef migrations add initial
dotnet ef database update

Start the application

dotnet run

If you're contributing to the UI part of the project:

cd CCUI.DAPPI
npm install
npm run start:dev

If you have questions or need guidance:

• Check the issues
• Create a new discussion or issue
• Or contact a maintainer

Thank you for helping improve DAPPI! 🚀