CrudX Framework

Enables CrudX framework functionality in your Spring Boot application.

Copy@SpringBootApplication
@CrudX
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

@CrudXUniqueConstraints

Container annotation for defining multiple unique constraints on an entity.

Copy@Entity
@CrudXUniqueConstraints({
    @CrudXUniqueConstraint(
        fields = {"email"},
        message = "Email already registered"
    ),
    @CrudXUniqueConstraint(
        fields = {"username"},
        message = "Username already taken"
    ),
    @CrudXUniqueConstraint(
        fields = {"phoneNumber"},
        message = "Phone number already registered"
    )
})
public class User extends CrudXMySQLEntity<Long> {
    private String email;
    private String username;
    private String phoneNumber;
}

@CrudXUniqueConstraint

Defines a unique constraint on one or more fields.

Copy@Entity
@CrudXUniqueConstraint(
    fields = {"email"},
    message = "Email address already exists"
)
public class User extends CrudXMySQLEntity<Long> {
    private String email;
}

Marks a field as immutable - cannot be updated after entity creation.

Copy@Entity
public class Employee extends CrudXMySQLEntity<Long> {
    
    @CrudXImmutable(message = "Employee code cannot be changed")
    private String employeeCode;
    
    @CrudXImmutable(message = "Hire date is permanent")
    private LocalDate hireDate;
    
    private String name;  // Can be updated
}

CrudXMySQLEntity<ID>

Base class for MySQL entities with auto-increment ID generation.

Copy@Entity
@Table(name = "employees")
public class Employee extends CrudXMySQLEntity<Long> {
    
    @Column(nullable = false)
    private String name;
    
    @Column(unique = true)
    private String email;
    
    private String department;
    private BigDecimal salary;
}

CrudXPostgreSQLEntity<ID>

Base class for PostgreSQL entities with sequence-based ID generation.

Copy@Entity
@Table(name = "products")
public class Product extends CrudXPostgreSQLEntity<Long> {
    private String name;
    private String sku;
    private BigDecimal price;
    private Integer stock;
}

CrudXMongoEntity<ID>

Base class for MongoDB documents with flexible schema.

Copy@Document(collection = "users")
public class User extends CrudXMongoEntity<String> {
    private String username;
    private String email;
    private List<String> roles;
    private Map<String, Object> metadata;
}

Create Single Entity

Creates a new entity in the database.

Copy{
  "name": "CrudX Starter",
  "email": "crudx@example.com",
  "department": "Engineering"
}

Copy{
  "success": true,
  "statusCode": 201,
  "data": {
    "id": 1,
    "name": "CrudX Starter"
  }
}

Create Batch

Creates multiple entities at once with intelligent chunking.

Get by ID

Retrieves a single entity by its ID.

Get All (Auto-Paginated)

Retrieves all entities with automatic pagination for large datasets (>1000).

Get Paginated

Retrieves entities with custom pagination parameters.

Partial Update

Updates specific fields of an entity with smart validation.

Copy{
  "department": "Management",
  "salary": 95000
}

Delete by ID

Deletes a single entity by its ID.

Delete Batch

Deletes multiple entities by their IDs (max 1000 per request).

Count

Returns the total count of entities.

Check Existence

Checks if an entity exists with the given ID.

CrudXService Interface

Copypublic interface CrudXService<T, ID> {
    
    // CREATE
    T create(T entity);
    BatchResult<T> createBatch(List<T> entities, boolean skipDuplicates);
    
    // READ
    T findById(ID id);
    List<T> findAll();
    Page<T> findAll(Pageable pageable);
    
    // UPDATE
    T update(ID id, Map<String, Object> updates);
    
    // DELETE
    void delete(ID id);
    BatchResult<ID> deleteBatch(List<ID> ids);
    
    // UTILITY
    long count();
    boolean existsById(ID id);
}

Using Service in Custom Logic

Copy@GetMapping("/department/{dept}")
public ResponseEntity<List<Employee>> getByDepartment(
        @PathVariable String dept) {
    
    List<Employee> all = crudService.findAll();
    
    List<Employee> filtered = all.stream()
        .filter(e -> dept.equals(e.getDepartment()))
        .collect(Collectors.toList());
    
    return ResponseEntity.ok(filtered);
}

Database Configuration

MySQL

Copyspring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb
    username: ${DB_USERNAME:root}
    password: ${DB_PASSWORD:password}
    driver-class-name: com.mysql.cj.jdbc.Driver
  
  jpa:
    hibernate:
      ddl-auto: update
    properties:
      hibernate:
        dialect: org.hibernate.dialect.MySQL8Dialect

PostgreSQL

Copyspring:
  datasource:
    url: jdbc:postgresql://localhost:5432/mydb
    username: ${DB_USERNAME:postgres}
    password: ${DB_PASSWORD:password}
  
  jpa:
    properties:
      hibernate:
        dialect: org.hibernate.dialect.PostgreSQLDialect

MongoDB

Copyspring:
  data:
    mongodb:
      uri: mongodb://localhost:27017/mydb
      database: mydb

CrudX Configuration

Copycrudx:
  database:
    auto-create: true  # Auto-create database if not exists
  
  performance:
    enabled: false     # Enable performance monitoring
    dashboard-enabled: true
    dashboard-path: /crudx/performance
  
  swagger:
    enabled: true      # Enable Swagger UI

Enable Monitoring

Copycrudx:
  performance:
    enabled: true

http://localhost:8080/crudx/performance/dashboard

Key Features

Error Codes

Error Response Format

Copy{
  "success": false,
  "message": "Email address already exists",
  "statusCode": 409,
  "status": "CONFLICT",
  "error": {
    "code": "DUPLICATE_ENTITY",
    "details": "Duplicate entry for unique constraint"
  },
  "timestamp": "2025-01-15T16:00:00"
}