Governed reporting, made natural for Spring Boot developers.

<dependency>
  <groupId>com.reportboot</groupId>
  <artifactId>report-boot-spring-boot-starter</artifactId>
  <version>0.1.0-MVP</version>
</dependency>

<!-- Add only the providers you use -->
<dependency>
  <groupId>com.reportboot</groupId>
  <artifactId>report-boot-jasper</artifactId>
  <version>0.1.0-MVP</version>
</dependency>

report-boot:
  templates-path: classpath:/report-boot/report-templates
  default-output: PDF
  database:
    initialize-schema: true
    schema: public
    table-prefix: rb_
  orders:
    type: jdbc
  storage:
    type: filesystem
    content-root: target/report-boot/reports
  governance:
    enabled: true
    instance-name: billing-service
  security:
    enabled: true
    default-expiry-minutes: 30
    max-expiry-minutes: 1440
    watermark-enabled: true
    one-time-download-enabled: false

<dependency>
  <groupId>com.reportboot</groupId>
  <artifactId>report-boot-core</artifactId>
  <version>0.1.0-MVP</version>
</dependency>

<dependency>
  <groupId>com.reportboot</groupId>
  <artifactId>report-boot-spring-boot-starter</artifactId>
  <version>0.1.0-MVP</version>
</dependency>

report-boot:
  templates-path: classpath:/report-boot/report-templates
  default-output: PDF
  database:
    initialize-schema: true
    schema: public
    table-prefix: rb_
  orders:
    type: jdbc
  storage:
    type: filesystem
    content-root: target/report-boot/reports
  governance:
    enabled: true
    instance-name: billing-service
  security:
    enabled: true
    default-expiry-minutes: 30
    max-expiry-minutes: 1440
    watermark-enabled: true
    one-time-download-enabled: false

GeneratedReport report = reportService.generate(request);

report.getReportOrderUuid();
report.getFileName();
report.getContentType();
report.getContent();
report.getGeneratedAt();
report.getAccessToken();
report.getAccessTokenExpiresAt();

@ReportTemplate(
    code = "invoice-basic",
    title = "Basic Invoice",
    templateFile = "classpath:/report-boot/report-templates/invoice-basic.jrxml",
    output = ReportOutput.PDF
)
@ReportEngineType(ReportEngine.JASPER)
@ReportSecured(watermark = true, expiryMinutes = 30)
@ReportFileName("invoice-${invoiceNumber}.pdf")
@ReportAccess(role = "ROLE_REPORT_ADMIN")
@ReportTitle("Invoice Report")
@ReportCategory("Billing")
public class InvoiceReportDto {
    @ReportField("invoiceNumber")
    @ReportRequired
    @ReportSensitive
    private String invoiceNumber;

    @ReportField("customerName")
    @ReportRequired
    private String customerName;

    @ReportField("invoiceDate")
    @ReportDateFormat("yyyy-MM-dd")
    private LocalDate invoiceDate;

    @ReportField("totalAmount")
    @ReportCurrency("USD")
    @ReportFormat(pattern = "#,##0.00")
    private BigDecimal totalAmount;

    @ReportTable("items")
    private List<InvoiceItemDto> items;
}

@RestController
@RequestMapping("/api/reports/jasper/invoice")
class InvoiceReportController {
    private final ReportService reportService;

    @PostMapping("/download")
    ResponseEntity<byte[]> download(@RequestBody InvoiceReportDto request) {
        GeneratedReport report = reportService.generate(request);
        return ResponseEntity.ok()
            .header(HttpHeaders.CONTENT_DISPOSITION,
                "attachment; filename=\"" + report.getFileName() + "\"")
            .contentType(MediaType.parseMediaType(report.getContentType()))
            .body(report.getContent());
    }
}

curl --location --request POST "http://localhost:8080/api/reports/jasper/invoice/download" \
  --header "Content-Type: application/json" \
  --data '{
  "invoiceNumber": "INV-2026-1001",
  "customerName": "Acme Corporation",
  "invoiceDate": "2026-07-13",
  "totalAmount": 499.00,
  "items": [
    {
      "itemName": "Report-Boot Enterprise License",
      "quantity": 1,
      "unitPrice": 499.00,
      "total": 499.00
    }
  ]
}' \
  --output "invoice.pdf"

src/main/resources/
  report-boot/
    report-templates/
      invoice-basic.jrxml
      invoice-basic.xlsx
      invoice-basic.rptdesign
      invoice-thymeleaf.html
    email-templates/
      invoice-report-ready.html
    sql/
      invoice-dashboard.sql

@ReportSecured(
    watermark = true,
    expiryMinutes = 5,
    oneTimeDownload = true
)
@ReportAccess(role = "ROLE_REPORT_ADMIN")
class ExternalInvoiceReport { ... }

<dependency>
  <groupId>com.reportboot</groupId>
  <artifactId>report-boot-jasper</artifactId>
  <version>0.1.0-MVP</version>
</dependency>

report-boot:
  renderer:
    jasper:
      enabled: true
      templates-path: classpath:/report-boot/report-templates
      cache-compiled-templates: true
  compilation:
    compile-on-startup: false
    fail-on-startup-error: true
    startup-threads: 0

<dependency>
  <groupId>com.reportboot</groupId>
  <artifactId>report-boot-jxls</artifactId>
  <version>0.1.0-MVP</version>
</dependency>

report-boot:
  renderer:
    jxls:
      enabled: true
      content-type: application/vnd.openxmlformats-officedocument.spreadsheetml.sheet
      throw-template-exceptions: true

<dependency>
  <groupId>com.reportboot</groupId>
  <artifactId>report-boot-birt</artifactId>
  <version>0.1.0-MVP</version>
</dependency>

report-boot:
  renderer:
    birt:
      enabled: true
      templates-path: classpath:/report-boot/report-templates
      cache-compiled-templates: true
      content-type: application/pdf

<dependency>
  <groupId>com.reportboot</groupId>
  <artifactId>report-boot-thymeleaf</artifactId>
  <version>0.1.0-MVP</version>
</dependency>

report-boot:
  renderer:
    thymeleaf:
      enabled: true
      templates-path: classpath:/report-boot/report-templates
      encoding: UTF-8
      content-type: text/html;charset=UTF-8
      template-mode: HTML

src/main/resources/
└── report-boot/
    ├── report-templates/
    │   ├── invoice.jrxml
    │   ├── invoice.xlsx
    │   ├── invoice.rptdesign
    │   └── invoice.html
    ├── email-templates/
    ├── sql/
    └── download-pages/

@Component
class CustomerApiDataProvider implements ReportDataProvider {
    @Override
    public ReportData load(ReportDefinition definition, Map<String, Object> parameters) {
        // Fetch from a trusted API, then return provider-neutral report data.
        return ReportData.builder().values(loadCustomers(parameters)).build();
    }
}

<dependency>
  <groupId>com.reportboot</groupId>
  <artifactId>report-boot-sql</artifactId>
  <version>0.1.0-MVP</version>
</dependency>

SqlReportSheet invoices = SqlReportSheet.builder()
    .sheetName("Invoices")
    .sqlFile("invoice-report.sql")
    .sortBy("Created On", "Invoice No")
    .excel(excel -> excel
        .header(style -> style
            .backgroundColor(ExcelColors.Section.HEADER_BACKGROUND)
            .fontColor(ExcelColors.Section.HEADER_TEXT)
            .bold(true))
        .column("Customer", column -> column.width(28))
        .column("Total", column -> column.format(CurrencyExcelFormats.USD))
        .formulaColumn("VAT", column -> column
            .round("Total", 2)
            .format(CurrencyExcelFormats.USD))
        .formulaColumn("Grand Total", column -> column
            .SUM("Total", "VAT")
            .format(CurrencyExcelFormats.USD)))
    .build();

SqlReportDefinition definition = SqlReportDefinition.builder()
    .code("invoice-workbook")
    .sheet(invoices)
    .maxRows(500_000)
    .queryTimeoutSeconds(120)
    .fetchSize(1000)
    .build();

report-boot:
  sql:
    enabled: true
    file-name-suffix: .xlsx
    expiry-minutes: 30
    tenant:
      column: tenant_id
      parameter-name: tenantId

<dependency>
  <groupId>com.reportboot</groupId>
  <artifactId>report-boot-excel</artifactId>
  <version>0.1.0-MVP</version>
</dependency>

SqlReportSheet invoices = SqlReportSheet.builder()
    .sheetName("Invoices")
    .sqlFile("invoice-report.sql")
    .sortBy("Created On", "Invoice No")
    .excel(excel -> excel
        .header(style -> style
            .backgroundColor(ExcelColors.Section.HEADER_BACKGROUND)
            .fontColor(ExcelColors.Section.HEADER_TEXT)
            .bold(true))
        .column("Customer", column -> column.width(28))
        .column("Total", column -> column.format(CurrencyExcelFormats.USD))
        .formulaColumn("VAT", column -> column
            .round("Total", 2)
            .format(CurrencyExcelFormats.USD))
        .formulaColumn("Grand Total", column -> column
            .SUM("Total", "VAT")
            .format(CurrencyExcelFormats.USD)))
    .build();

SqlReportDefinition definition = SqlReportDefinition.builder()
    .code("invoice-workbook")
    .sheet(invoices)
    .maxRows(500_000)
    .queryTimeoutSeconds(120)
    .fetchSize(1000)
    .build();

<dependency>
  <groupId>com.reportboot</groupId>
  <artifactId>report-boot-csv</artifactId>
  <version>0.1.0-MVP</version>
</dependency>

report-boot:
  csv:
    enabled: true
    delimiter: ","
    include-header: true
    charset: UTF-8

GeneratedReport report = reportService.generate(
    "invoice-summary",
    definition,
    parameters,
    ReportOutput.CSV
);

@ReportTemplate(
    code = "existing-finance-export",
    title = "Existing Finance Export",
    templateFile = "existing-finance-export",
    output = ReportOutput.EXCEL
)
@ReportEngineType(ReportEngine.CUSTOM)
@ReportFileName("finance.xlsx")
@ReportSecured(expiryMinutes = 30, oneTimeDownload = true)
@ReportDescription("Existing export governed by Report-Boot.")
public class ExistingFinanceExportConfig {
}

byte[] bytes = existingFinanceExporter.export(request);

GeneratedReport report = customReportExportService.exportBytes(
        ExistingFinanceExportConfig.class,
        bytes,
        ReportOutput.EXCEL,
        "finance.xlsx",
        "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");

byte[] pdf = existingPdfRenderer.render(request);

GeneratedReport report = customReportExportService.exportBytes(
        ExistingFinancePdfConfig.class,
        pdf,
        ReportOutput.PDF,
        "finance.pdf",
        "application/pdf");

@GetMapping("/reports/{uuid}/download")
ResponseEntity<StreamingResponseBody> download(
        @PathVariable UUID uuid,
        @RequestParam(name = "token", required = false) String token) {

    GeneratedReport report = token == null || token.isBlank()
            ? reportService.download(uuid)
            : reportService.download(uuid, token);

    return ReportDownloadResponseBuilder.attachment(report);
}

String downloadUrl = UriComponentsBuilder
        .fromHttpUrl("https://app.example.com/reports/" + report.getReportOrderUuid() + "/download")
        .queryParam("token", report.getAccessToken())
        .toUriString();

reportEmailSender.send(ReportEmail.builder()
        .to("finance@example.com")
        .subject("Secure finance report")
        .html("<p>Download your report: <a href=\"" + downloadUrl + "\">Open secure link</a></p>")
        .metadata("deliveryMode", "secure-link")
        .metadata("reportOrderUuid", report.getReportOrderUuid())
        .build());

SqlReportSheet invoices = SqlReportSheet.builder()
    .sheetName("Invoices")
    .sqlFile("invoice-report.sql")
    .sortBy("Created On", "Invoice No")
    .excel(excel -> excel
        .header(style -> style
            .backgroundColor(ExcelColors.Section.HEADER_BACKGROUND)
            .fontColor(ExcelColors.Section.HEADER_TEXT)
            .bold(true))
        .column("Customer", column -> column.width(28))
        .column("Total", column -> column.format(CurrencyExcelFormats.USD))
        .formulaColumn("VAT", column -> column
            .round("Total", 2)
            .format(CurrencyExcelFormats.USD))
        .formulaColumn("Grand Total", column -> column
            .SUM("Total", "VAT")
            .format(CurrencyExcelFormats.USD)))
    .build();

SqlReportDefinition definition = SqlReportDefinition.builder()
    .code("invoice-workbook")
    .sheet(invoices)
    .maxRows(500_000)
    .queryTimeoutSeconds(120)
    .fetchSize(1000)
    .build();

@GetMapping("/download")
ResponseEntity<byte[]> download(
        @RequestParam LocalDate fromDate,
        @RequestParam LocalDate toDate,
        @RequestParam String tenantId,
        @RequestParam(defaultValue = "EXCEL") ReportOutput output) {
    GeneratedReport report = reportService.generate(
        "invoice-workbook",
        invoiceDefinitions.invoiceSummary(),
        Map.of("fromDate", fromDate, "toDate", toDate, "tenantId", tenantId),
        output
    );
    return downloadResponse(report);
}

select customer_name as "Customer",
       total as "Total"
from invoices

.column("Total", c -> c.format(CurrencyExcelFormats.USD))
.formulaColumn("VAT", c -> c.round("Total", 2))
.formulaColumn("Grand Total", c -> c.SUM("Total", "VAT"))
.summaryFooter(f -> f.formula("Grand Total", c -> c.SUM("Grand Total")))
.addChart(DynamicExcelColumnChart.of(c -> c
    .categoryColumn("Customer")
    .valueColumn("Grand Total")))

.formulaColumn("VAT", column -> column
    .round("Total", 2)
    .format(CurrencyExcelFormats.USD))

.formulaColumn("Grand Total", column -> column
    .SUM("Total", "VAT", "Shipping"))

.formulaColumn("Invoice Label", column -> column
    .concatenate("Customer", "Invoice No")) // default: " - "

.formulaColumn("Compact Label", column -> column
    .concatenate("Customer", "Invoice No")
    .symbol(" / "))

.formulaColumn("Payment Flag", column -> column
    .IF("Paid", "Paid", "Outstanding"))

ABS, ABSREF, ACOS, ACOSH, ADDRESS, AND, APP_TITLE, AREAS, ARGUMENT, ASC,
ASIN, ASINH, ATAN, ATAN2, ATANH, AVEDEV, AVERAGE, AVERAGEA, BETADIST, BETAINV,
BINOMDIST, CALL, CEILING, CELL, CHAR, CHIDIST, CHIINV, CHITEST, CHOOSE, CLEAN,
CODE, COLUMN, COLUMNS, COMBIN, CONCATENATE, CONFIDENCE, CORREL, COS, COSH, COUNT,
COUNTA, COUNTBLANK, COUNTIF, COVAR, CRITBINOM, DATE, DATEDIF, DATESTRING, DATEVALUE,
DAVERAGE, DAY, DAYS360, DB, DBCS, DCOUNT, DCOUNTA, DDB, DEGREES, DEVSQ, DGET,
DMAX, DMIN, DOLLAR, DPRODUCT, DSTDEV, DSTDEVP, DSUM, DVAR, DVARP, ENABLE_TOOL,
END_IF, ERROR, ERROR_TYPE, EVALUATE, EVEN, EXACT, EXEC, EXP, EXPONDIST, FACT,
FALSE, FDIST, FIND, FINDB, FINV, FISHER, FISHERINV, FIXED, FLOOR, FORECAST,
FREQUENCY, FTEST, FV, GAMMADIST, GAMMAINV, GAMMALN, GEOMEAN, GET_CELL, GET_DOCUMENT,
GET_WINDOW, GET_WORKBOOK, GET_WORKSPACE, GETPIVOTDATA, GOTO, GROWTH, HARMEAN,
HLOOKUP, HOUR, HYPERLINK, HYPGEOMDIST, IF, INDEX, INDIRECT, INFO, INT, INTERCEPT,
IPMT, IRR, ISBLANK, ISERR, ISERROR, ISLOGICAL, ISNA, ISNONTEXT, ISNUMBER, ISPMT,
ISREF, ISTEXT, JIS, KURT, LARGE, LAST_ERROR, LEFT, LEFTB, LEN, LENB, LINEST, LN,
LOG, LOG10, LOGEST, LOGINV, LOGNORMDIST, LOOKUP, LOWER, MATCH, MAX, MAXA, MDETERM,
MEDIAN, MID, MIDB, MIN, MINA, MINUTE, MINVERSE, MIRR, MMULT, MOD, MODE, MONTH,
N, NA, NEGBINOMDIST, NORMDIST, NORMINV, NORMSDIST, NORMSINV, NOT, NOW, NPER,
NPV, NUMBERSTRING, ODD, OFFSET, OR, PEARSON, PERCENTILE, PERCENTRANK, PERMUT,
PHONETIC, PI, PMT, POISSON, POWER, PPMT, PRESS_TOOL, PROB, PRODUCT, PROPER, PV,
QUARTILE, RADIANS, RAND, RANK, RATE, REGISTER_ID, RELREF, REPLACE, REPLACEB, REPT,
RETURN, RIGHT, RIGHTB, ROMAN, ROUND, ROUNDDOWN, ROUNDUP, ROW, ROWS, RSQ,
SAVE_TOOLBAR, SEARCH, SEARCHB, SECOND, SIGN, SIN, SINH, SKEW, SLN, SLOPE, SMALL,
SQRT, STANDARDIZE, STDEV, STDEVA, STDEVP, STDEVPA, STEP, STEYX, SUBSTITUTE,
SUBTOTAL, SUM, SUMIF, SUMPRODUCT, SUMSQ, SUMX2MY2, SUMX2PY2, SUMXMY2, SYD, T,
TAN, TANH, TDIST, TEXT, TIME, TIMEVALUE, TINV, TODAY, TRANSPOSE, TREND, TRIM,
TRIMMEAN, TRUE, TRUNC, TTEST, TYPE, UPPER, USDOLLAR, VALUE, VAR, VARA, VARP,
VARPA, VDB, VLOOKUP, WEEKDAY, WEIBULL, WINDOW_TITLE, YEAR, YEN, ZTEST

.columnBackground("Status", ExcelColors.Palette.GRAY_50)
.column("Status", c -> c.bold(true))
.conditionalFormat("Status", rule -> rule
    .equalTo("Failed")
    .style(s -> s
        .backgroundColor(ExcelColors.Status.ERROR_BG)
        .fontColor(ExcelColors.Status.ERROR_TEXT)))

SqlReportSheet.builder()
    .sheetName("Department Report")
    .sqlFile("department-report.sql")
    .groupBy("Department", "Market")
    .sortBy("Department", "Market", "Employee")
    .betweenGroupSpaceRows(3)
    .excel(excel -> excel
        .columnGroup("Employee", "Department", "Market", "Employee")
        .columnGroup("Money", "Gross", "VAT", "Net")
        .summaryFooter(footer -> footer
            .label("Slice Total")
            .labelColumn("Employee")
            .formula("Gross", f -> f.SUM("Gross"))
            .formula("VAT", f -> f.SUM("VAT"))
            .formula("Net", f -> f.SUM("Net"))))
    .build();

.sectionCell(new DynamicExcelSectionCell(
    1, 1,
    DynamicExcelSectionCellType.TEXT,
    "Monthly Revenue Report",
    DynamicExcelCellStyle.of(s -> s.bold(true).fontSize(16)),
    5, 1
))

.addKpi(DynamicExcelKpiCard.of(kpi -> kpi
    .title("Sliced Revenue")
    .valueColumn("Revenue")
    .aggregation(DynamicExcelAggregationType.SUM)))
.addSlice(DynamicExcelDropdownSlice.of(slice -> slice
    .title("Payment Status")
    .column("Payment Status")))
.addChart(DynamicExcelLineChart.of(chart -> chart
    .title("Revenue Trend")
    .categoryColumn("Day Label")
    .valueColumn("Revenue")))

<dependency>
  <groupId>com.reportboot</groupId>
  <artifactId>report-boot-email</artifactId>
  <version>0.1.0-MVP</version>
</dependency>

spring:
  mail:
    host: ${REPORT_BOOT_SMTP_HOST}
    port: ${REPORT_BOOT_SMTP_PORT:587}
    username: ${REPORT_BOOT_SMTP_USERNAME}
    password: ${REPORT_BOOT_SMTP_PASSWORD}
report-boot:
  email:
    enabled: true
    from: ${REPORT_BOOT_EMAIL_FROM}
    templates-path: classpath:/report-boot/email-templates

ReportEmail email = ReportEmail.builder()
    .jobKey("month-end-invoice")
    .idempotencyKey("invoice-2026-07-final")
    .to("finance@example.com")
    .subject("Invoice report")
    .template("invoice-report-ready")
    .data("invoiceNumber", "INV-1001")
    .metadata("username", currentUser)
    .metadata("tenantId", tenantId)
    .attachReport(invoiceDto)
    .build();

ReportEmailResult result = reportEmailSender.send(email);

@Component
@ReportEmailJob(
    key = "daily-invoice-email",
    name = "Daily Invoice Email",
    cron = "0 0 8 * * *",
    subject = "Daily invoice report",
    template = "daily-invoice-email"
)
@ReportEmailCondition(
    field = "totalAmount",
    operator = ReportEmailConditionOperator.GREATER_THAN,
    value = "0"
)
class DailyInvoiceEmailJob implements ReportEmailJobProvider {
    public ReportEmail buildEmail() {
        return ReportEmail.builder()
            .to(recipient)
            .template("daily-invoice-email")
            .attachReport(sampleReport())
            .build();
    }
}

report-boot:
  orders:
    type: jdbc
  storage:
    type: filesystem
    content-root: /var/lib/report-boot/reports
  access-token:
    enabled: true
    secret: ${REPORT_BOOT_ACCESS_TOKEN_SECRET}
    issuer: report-boot
  download-page:
    enabled: true
    mode: render
    redirect-url: /report-boot/download-unavailable
    page-location: ""
    include-details-in-redirect: true

report-boot:
  database:
    initialize-schema: true
    schema: reporting
    table-prefix: rb_

@Component
class JpaReportBootLogSink implements ReportBootLogSink {
    private final LibraryLogEntryRepository repository;

    @Override
    public void persist(ReportBootLogEntry entry) {
        repository.save(ReportBootLogEntity.from(entry));
    }
}

report-boot:
  insights:
    enabled: true
    mode: db_only
    logs:
      enabled: true
      logger-prefix: com.reportboot
      marker: REPORT_BOOT_LIBRARY
      ring-buffer-size: 1000

@PostMapping("/api/reports/designer/sql-excel/download")
ResponseEntity<byte[]> download(@RequestBody DesignerSqlExcelRequest request) {
    SqlReportDefinition definition = designerDefinitionService.buildDefinition(request);
    GeneratedReport report = reportService.generate(
        request.reportCode(), definition, request.parameters(), ReportOutput.EXCEL);
    return downloadResponse(report);
}

@PostMapping(value = "/download", consumes = MediaType.APPLICATION_JSON_VALUE)
ResponseEntity<byte[]> download(@RequestBody DesignerSqlExcelRequest request) {
    SqlReportDefinition definition = definitions.buildDefinition(request);
    GeneratedReport report = reportService.generate(
        definitions.reportCode(request), definition, request.parameters(), ReportOutput.EXCEL);
    return downloadResponse(report);
}

report-boot:
  ai:
    enabled: true
    max-prompt-characters: 4000
    gemini:
      api-key: ${REPORT_BOOT_AI_GEMINI_API_KEY}
      default-model: gemini-flash-latest
      allowed-models: [gemini-flash-latest, gemini-2.5-flash]
      request-timeout: 45s
      temperature: 0.2
    designer-proxy:
      enabled: true
      require-proxy-token: true
      token-header: X-Report-Boot-AI-Token
      proxy-token: ${REPORT_BOOT_AI_PROXY_TOKEN}

report-boot:
  ai:
    enabled: false
    max-prompt-characters: 4000
    gemini:
      api-key: ${REPORT_BOOT_AI_GEMINI_API_KEY}
      default-model: gemini-flash-latest
      allowed-models: [gemini-flash-latest, gemini-2.5-flash]
      request-timeout: 45s
      temperature: 0.2
    designer-proxy:
      enabled: true
      path: /api/report-boot/ai/designer/generate
      require-proxy-token: true
      token-header: X-Report-Boot-AI-Token
      proxy-token: ${REPORT_BOOT_AI_PROXY_TOKEN}

./mvnw spring-boot:run -pl library/report-boot-demo -am

$env:REPORT_BOOT_DATASOURCE_URL="jdbc:postgresql://localhost:5432/report_boot_control_center"
$env:REPORT_BOOT_DATASOURCE_USERNAME="report_boot"
$env:REPORT_BOOT_DATASOURCE_PASSWORD="report_boot"
mvn -pl library/report-boot-demo -am spring-boot:run

./mvnw spring-boot:run -pl library/report-boot-demo -am

docs/postman/report-boot-demo.postman_collection.json

const body = pm.response.json();
pm.environment.set("reportOrderUuid", body.reportOrderUuid);

REPORT_BOOT_DATASOURCE_URL=jdbc:postgresql://db:5432/report_boot
REPORT_BOOT_DATASOURCE_USERNAME=report_boot
REPORT_BOOT_DATASOURCE_PASSWORD=<secret>
REPORT_BOOT_DATABASE_SCHEMA=public
REPORT_BOOT_INSTANCE_NAME=billing-service-01

REPORT_BOOT_STORAGE_CONTENT_ROOT=/var/lib/report-boot/reports
REPORT_BOOT_ACCESS_TOKEN_SECRET=<at-least-32-random-bytes>
REPORT_BOOT_ACCESS_TOKEN_ISSUER=report-boot

REPORT_BOOT_SMTP_HOST=smtp.example.com
REPORT_BOOT_SMTP_PORT=587
REPORT_BOOT_SMTP_USERNAME=reports@example.com
REPORT_BOOT_SMTP_PASSWORD=<smtp-secret-or-app-password>
REPORT_BOOT_SMTP_FROM=reports@example.com
REPORT_BOOT_SMTP_FROM_NAME=Report-Boot
REPORT_BOOT_SMTP_AUTH=true
REPORT_BOOT_SMTP_STARTTLS=true

REPORT_BOOT_AI_GEMINI_API_KEY=<optional-secret>
REPORT_BOOT_AI_PROXY_TOKEN=<optional-secret>

@ReportTemplate(
    code = "invoice-basic",
    title = "Basic Invoice",
    templateFile = "classpath:/report-boot/report-templates/invoice-basic.jrxml",
    output = ReportOutput.PDF
)
@ReportEngineType(ReportEngine.JASPER)
@ReportSecured(watermark = true, expiryMinutes = 30)
@ReportFileName("invoice-${invoiceNumber}.pdf")
@ReportAccess(role = "ROLE_REPORT_ADMIN")
@ReportTitle("Invoice Report")
@ReportCategory("Billing")
public class InvoiceReportDto {
    @ReportField("invoiceNumber")
    @ReportRequired
    @ReportSensitive
    private String invoiceNumber;

    @ReportField("customerName")
    @ReportRequired
    private String customerName;

    @ReportField("invoiceDate")
    @ReportDateFormat("yyyy-MM-dd")
    private LocalDate invoiceDate;

    @ReportField("totalAmount")
    @ReportCurrency("USD")
    @ReportFormat(pattern = "#,##0.00")
    private BigDecimal totalAmount;

    @ReportTable("items")
    private List<InvoiceItemDto> items;
}

@RestController
@RequestMapping("/api/reports/jasper/invoice")
class InvoiceReportController {
    private final ReportService reportService;

    @PostMapping("/download")
    ResponseEntity<byte[]> download(@RequestBody InvoiceReportDto request) {
        GeneratedReport report = reportService.generate(request);
        return ResponseEntity.ok()
            .header(HttpHeaders.CONTENT_DISPOSITION,
                "attachment; filename=\"" + report.getFileName() + "\"")
            .contentType(MediaType.parseMediaType(report.getContentType()))
            .body(report.getContent());
    }
}

{
  "invoiceNumber": "INV-2026-1001",
  "customerName": "Acme Corporation",
  "invoiceDate": "2026-07-13",
  "totalAmount": 499.00,
  "items": [
    {
      "itemName": "Report-Boot Enterprise License",
      "quantity": 1,
      "unitPrice": 499.00,
      "total": 499.00
    }
  ]
}

curl --location --request POST "http://localhost:8080/api/reports/jasper/invoice" \
+  --header "Content-Type: application/json" \
+  --data '{
  "invoiceNumber": "INV-2026-1001",
  "customerName": "Acme Corporation",
  "invoiceDate": "2026-07-13",
  "totalAmount": 499.00,
  "items": [
    {
      "itemName": "Report-Boot Enterprise License",
      "quantity": 1,
      "unitPrice": 499.00,
      "total": 499.00
    }
  ]
}'

curl --location "http://localhost:8080/api/reports/jasper/invoice/{reportOrderUuid}/download" \
+  --header "Accept: application/pdf" \
+  --output invoice.pdf

SqlReportSheet invoices = SqlReportSheet.builder()
    .sheetName("Invoices")
    .sqlFile("invoice-report.sql")
    .sortBy("Created On", "Invoice No")
    .excel(excel -> excel
        .header(style -> style
            .backgroundColor(ExcelColors.Section.HEADER_BACKGROUND)
            .fontColor(ExcelColors.Section.HEADER_TEXT)
            .bold(true))
        .column("Customer", column -> column.width(28))
        .column("Total", column -> column.format(CurrencyExcelFormats.USD))
        .formulaColumn("VAT", column -> column
            .round("Total", 2)
            .format(CurrencyExcelFormats.USD))
        .formulaColumn("Grand Total", column -> column
            .SUM("Total", "VAT")
            .format(CurrencyExcelFormats.USD)))
    .build();

SqlReportDefinition definition = SqlReportDefinition.builder()
    .code("invoice-workbook")
    .sheet(invoices)
    .maxRows(500_000)
    .queryTimeoutSeconds(120)
    .fetchSize(1000)
    .build();

curl --location "http://localhost:8080/api/reports/sql/invoices/download?fromDate=2026-06-01&toDate=2026-06-30&tenantId=tenant-demo&output=EXCEL" --output "invoices.xlsx"

curl --location "http://localhost:8080/api/reports/sql/invoices/download?fromDate=2026-06-01&toDate=2026-06-30&tenantId=tenant-demo&output=CSV" --output "invoices.zip"

.formulaColumn("Grand Total", c -> c.SUM("Total", "VAT", "Shipping"))
.formulaColumn("Label", c -> c.concatenate("Customer", "Invoice No"))
.formulaColumn("Rounded", c -> c.round("Total", 2))

curl --location "http://localhost:8080/api/reports/sql/invoices/formulas/download?fromDate=2026-06-01&toDate=2026-06-30&tenantId=tenant-demo" --output "formula-playground.xlsx"

curl --location "http://localhost:8080/api/reports/sql/invoices/formulas/all/download?fromDate=2026-06-01&toDate=2026-06-30&tenantId=tenant-demo" --output "formula-catalog.xlsx"

# Backward-compatible alias
curl --location "http://localhost:8080/api/reports/sql/invoices/quick-formula/download" --output "quick-formula.xlsx"

.groupBy("Customer")
.sortBy("Customer", "Created On", "Invoice No")
.betweenGroupSpaceRows(2)
.excel(excel -> excel
    .columnGroup("Invoice", "Invoice No", "Customer", "Created On")
    .columnGroup("Money", "Total", "VAT", "Grand Total")
    .summaryFooter(...))

curl --location "http://localhost:8080/api/reports/sql/invoices/group-sort/download?fromDate=2026-06-01&toDate=2026-06-10&tenantId=tenant-demo" --output "grouped.xlsx"

curl --location "http://localhost:8080/api/reports/sql/invoices/group-headers/download?fromDate=2026-06-01&toDate=2026-06-10&tenantId=tenant-demo" --output "grouped-headers.xlsx"

.addChart(DynamicExcelLineChart.of(c -> c
    .title("Revenue Trend")
    .categoryColumn("Day Label")
    .valueColumn("Revenue")))
.addChart(DynamicExcelScatterChart.of(c -> c
    .title("Revenue Relationship")
    .categoryColumn("Day No")
    .valueColumn("Revenue")))

curl --location "http://localhost:8080/api/reports/excel/dashboards/invoices/download?fromDate=2026-06-01&toDate=2026-06-30&tenantId=tenant-demo" --output "invoice-dashboard.xlsx"

curl --location "http://localhost:8080/api/reports/excel/dashboards/invoices/filters/download?fromDate=2026-06-01&toDate=2026-06-30&tenantId=tenant-demo" --output "invoice-filter-dashboard.xlsx"

.addSlice(DynamicExcelDropdownSlice.of(s -> s
    .title("Payment Status")
    .column("Payment Status")))
.addSlice(DynamicExcelDropdownSlice.of(s -> s
    .title("Customer")
    .column("Customer")))
.addSlice(DynamicExcelDropdownSlice.of(s -> s
    .title("Day")
    .column("Day Label")))

curl --location "http://localhost:8080/api/reports/excel/dashboards/invoices/sliced/download?fromDate=2026-06-01&toDate=2026-06-30&tenantId=tenant-demo" --output "invoice-sliced-dashboard.xlsx"

curl --location --request POST "http://localhost:8080/api/reports/designer/sql-excel/download" \
  --header "Content-Type: application/json" \
  --data @designer-report.json \
  --output "designer-report.xlsx"

curl --location --request POST "http://localhost:8080/api/reports/designer/sql-excel/download" \
  --form "file=@designer-report.json;type=application/json" \
  --output "designer-report.xlsx"

curl --location --request POST "http://localhost:8080/api/reports/designer/ai/generate" \
+  --header "Content-Type: application/json" \
+  --header "X-Report-Boot-AI-Token: $REPORT_BOOT_AI_PROXY_TOKEN" \
+  --data '{
    "prompt": "Create an invoice report grouped by customer and date",
    "mode": "design",
    "model": "gemini-flash-latest",
    "currentRequest": null,
    "context": {"templateType": "sql-excel"}
  }'

curl --location --request POST "http://localhost:8080/api/reports/designer/sql-excel/download" \
+  --header "Content-Type: application/json" \
+  --data @approved-designer-request.json \
+  --output designer-report.xlsx

{
  "to": ["developer@example.com"],
  "cc": [],
  "bcc": [],
  "subject": "Your invoice report is ready",
  "templateName": "invoice-report-ready",
  "idempotencyKey": "invoice-INV-2026-1001-v1",
  "report": {
  "invoiceNumber": "INV-2026-1001",
  "customerName": "Acme Corporation",
  "invoiceDate": "2026-07-13",
  "totalAmount": 499.00,
  "items": [
    {
      "itemName": "Report-Boot Enterprise License",
      "quantity": 1,
      "unitPrice": 499.00,
      "total": 499.00
    }
  ]
}
}

curl --location --request POST "http://localhost:8080/api/reports/email/jasper/invoice" \
  --header "Content-Type: application/json" \
  --data '{
  "to": ["developer@example.com"],
  "cc": [],
  "bcc": [],
  "subject": "Your invoice report is ready",
  "templateName": "invoice-report-ready",
  "idempotencyKey": "invoice-INV-2026-1001-v1",
  "report": {
  "invoiceNumber": "INV-2026-1001",
  "customerName": "Acme Corporation",
  "invoiceDate": "2026-07-13",
  "totalAmount": 499.00,
  "items": [
    {
      "itemName": "Report-Boot Enterprise License",
      "quantity": 1,
      "unitPrice": 499.00,
      "total": 499.00
    }
  ]
}
}'

# Change only the provider path:
# /jxls/invoice
# /birt/invoice
# /thymeleaf/invoice

@ReportSecured(watermark = true, expiryMinutes = 5, oneTimeDownload = true)
class InvoiceThymeleafDownloadLinkReportDto { ... }

curl --location --request POST "http://localhost:8080/api/reports/email/thymeleaf/invoice/download-link" \
  --header "Content-Type: application/json" \
  --data '{
  "to": ["developer@example.com"],
  "cc": [],
  "bcc": [],
  "subject": "Your invoice report is ready",
  "templateName": "invoice-report-ready",
  "idempotencyKey": "invoice-INV-2026-1001-v1",
  "report": {
  "invoiceNumber": "INV-2026-1001",
  "customerName": "Acme Corporation",
  "invoiceDate": "2026-07-13",
  "totalAmount": 499.00,
  "items": [
    {
      "itemName": "Report-Boot Enterprise License",
      "quantity": 1,
      "unitPrice": 499.00,
      "total": 499.00
    }
  ]
}
}'

@ReportEmailJob(
    key = "demo-daily-invoice-email",
    name = "Demo Daily Invoice Email",
    cron = "0 0 8 * * *",
    subject = "Daily invoice report",
    template = "daily-invoice-email"
)
@ReportEmailCondition(
    field = "totalAmount",
    operator = ReportEmailConditionOperator.GREATER_THAN,
    value = "0"
)

select * from public.rb_email_job where job_key = 'demo-daily-invoice-email';
select * from public.rb_email_run order by started_at desc;
select * from public.rb_email_log order by finished_at desc;

curl.exe -i -H "Accept: application/json" "http://localhost:8085/api/control/v1/logs/recent?limit=20"

curl.exe -i -N -H "Accept: text/event-stream" "http://localhost:8085/api/control/v1/logs/stream"

curl.exe -i -X POST "http://localhost:8085/api/control/v1/logs/emit?level=ERROR&count=1&message=seeded-error&correlation-id=cid_12ab&report-name=invoice-basic&template-code=invoice-basic&error-stack=java.lang.RuntimeException%3A+boom"