@openmrs/esm-report-builder 0.1.1-pre.87

package/src/resources/report-import-export/import-export-api.ts

@@ -0,0 +1,164 @@
+import { omrsGet, omrsPost } from '../openmrs-api';
+
+const EXPORT_RESOURCE = '/reportbuilder/ship';
+const IMPORT_RESOURCE = '/reportbuilder/import';
+
+// Backend response wrapper
+type BackendResponse<T> = {
+  success: boolean;
+  message?: string;
+  data?: T;
+};
+
+// Types for Export API
+export type ShippingRequest = {
+  type: 'compiledReports' | 'artifacts';
+  version?: string;
+  destination?: string;
+};
+
+export type ExportResultData = {
+  reportCode?: string;
+  version?: string;
+  sourceFile?: string;
+  compiledFile?: string;
+  versionFile?: string;
+  dependencies?: {
+    categories?: string[];
+    indicators?: string[];
+    themes?: string[];
+    sections?: string[];
+    library?: string[];
+    ageCategories?: string[];
+    ageGroups?: string[];
+    etlSources?: string[];
+    etlMonitors?: string[];
+  };
+};
+
+export type ExportResult = {
+  success: boolean;
+  message?: string;
+  reportCode?: string;
+  version?: string;
+  sourceFile?: string;
+  compiledFile?: string;
+  versionFile?: string;
+  dependencies?: ExportResultData['dependencies'];
+  errorMessage?: string;
+};
+
+// Types for Import API
+export type ImportRequest = {
+  type: 'compiledReports' | 'artifacts';
+  sourceDirectory?: string; // Optional - backend uses default location if not provided
+};
+
+export type ImportItem = {
+  type: string;
+  filename: string;
+  status?: 'success' | 'error';
+  error?: string;
+};
+
+export type ImportResult = {
+  success: boolean;
+  summary?: string;
+  successCount?: number;
+  errorCount?: number;
+  successes?: ImportItem[];
+  errors?: ImportItem[];
+  errorMessage?: string;
+};
+
+// Types for Package Info
+export type PackageDependencySummary = {
+  categories?: number;
+  indicators?: number;
+  themes?: number;
+  sections?: number;
+  library?: number;
+  ageCategories?: number;
+  ageGroups?: number;
+  etlSources?: number;
+  etlMonitors?: number;
+};
+
+export type PackageInfo = {
+  name: string;
+  version: string;
+  description?: string;
+  exportedAt?: string;
+  exportedBy?: string;
+  size: number;
+  status: 'valid' | 'invalid';
+  dependencies?: PackageDependencySummary;
+  path?: string;
+};
+
+// API Functions
+
+/**
+ * Export reports or artifacts based on the type specified in the request.
+ * Uses a unified endpoint with type-based routing.
+ */
+export async function exportReports(
+  request: ShippingRequest,
+  signal?: AbortSignal,
+): Promise<ExportResult> {
+  const response = await omrsPost<BackendResponse<ExportResultData>>(EXPORT_RESOURCE, request, signal);
+  return {
+    success: response.success,
+    message: response.message,
+    ...response.data,
+    errorMessage: response.success ? undefined : response.message,
+  };
+}
+
+/**
+ * Import reports or artifacts based on the type specified in the request.
+ * Uses a unified endpoint with type-based routing.
+ */
+export async function importReports(
+  request: ImportRequest,
+  signal?: AbortSignal,
+): Promise<ImportResult> {
+  return omrsPost<ImportResult>(IMPORT_RESOURCE, request, signal);
+}
+
+export async function validatePackage(
+  path: string,
+  signal?: AbortSignal,
+): Promise<{ valid: boolean; error?: string }> {
+  // This endpoint might need to be implemented on the backend
+  // For now, return a placeholder
+  return omrsGet<{ valid: boolean; error?: string }>(
+    `/reportbuilder/validate-package?path=${encodeURIComponent(path)}`,
+    signal,
+  );
+}
+
+export async function getAvailablePackages(
+  params?: { q?: string; status?: string; startIndex?: number; limit?: number },
+  signal?: AbortSignal,
+): Promise<PackageInfo[]> {
+  const queryParams = new URLSearchParams();
+  if (params?.q) {
+    queryParams.set('q', params.q);
+  }
+  if (params?.status) {
+    queryParams.set('status', params.status);
+  }
+  if (params?.startIndex !== undefined) {
+    queryParams.set('startIndex', params.startIndex.toString());
+  }
+  if (params?.limit !== undefined) {
+    queryParams.set('limit', params.limit.toString());
+  }
+
+  const queryString = queryParams.toString();
+  const url = `/ws/rest/v1/reportbuilder/packages${queryString ? `?${queryString}` : ''}`;
+
+  const response = await omrsGet<{ results: PackageInfo[] }>(url, signal);
+  return response.results || [];
+}

package/src/resources/report-library/report-library.api.ts

@@ -0,0 +1,63 @@
+import { omrsDelete, omrsGet, omrsPost } from '../openmrs-api';
+
+type RestList<T> = { results?: T[] } & Record<string, any>;
+
+function unwrapRestList<T>(data: RestList<T> | T[] | undefined): T[] {
+  if (!data) return [];
+  if (Array.isArray(data)) return data;
+  return Array.isArray(data.results) ? data.results : [];
+}
+
+const RESOURCE = '/reportbuilder/reportlibrary';
+
+export type ReportSourceType = 'LEGACY' | 'BUILDER';
+export type ReportType = 'AGGREGATE' | 'LINE_LIST';
+
+export type ReportLibraryDto = {
+  uuid: string;
+  display?: string;
+  name: string;
+  description?: string;
+  code?: string;
+  sourceType?: ReportSourceType;
+  reportDefinitionUuid?: string;
+  reportBuilderReportUuid?: string;
+  reportType?: ReportType;
+  migrated?: boolean;
+  metaJson?: string;
+  retired?: boolean;
+  category?: { uuid: string; name?: string } | string;
+};
+
+export type SaveReportLibraryPayload = {
+  name: string;
+  description?: string;
+  code?: string;
+  sourceType?: ReportSourceType;
+  reportDefinitionUuid?: string;
+  reportBuilderReportUuid?: string;
+  reportType?: ReportType;
+  migrated?: boolean;
+  metaJson?: string;
+  category?: string;
+};
+
+export async function listReportLibraries(q?: string, signal?: AbortSignal): Promise<ReportLibraryDto[]> {
+  const qs = new URLSearchParams();
+  qs.set('v', 'full');
+  if (q?.trim()) qs.set('q', q.trim());
+  const data = await omrsGet<RestList<ReportLibraryDto> | ReportLibraryDto[]>(`${RESOURCE}?${qs.toString()}`, signal);
+  return unwrapRestList(data).filter((x) => Boolean(x?.uuid));
+}
+
+export async function createReportLibrary(payload: SaveReportLibraryPayload, signal?: AbortSignal): Promise<ReportLibraryDto> {
+  return omrsPost<ReportLibraryDto>(RESOURCE, payload, signal);
+}
+
+export async function updateReportLibrary(uuid: string, payload: SaveReportLibraryPayload, signal?: AbortSignal): Promise<ReportLibraryDto> {
+  return omrsPost<ReportLibraryDto>(`${RESOURCE}/${encodeURIComponent(uuid)}`, payload, signal);
+}
+
+export async function deleteReportLibrary(uuid: string, reason = 'Retired from report library', signal?: AbortSignal): Promise<any> {
+  return omrsDelete<any>(`${RESOURCE}/${encodeURIComponent(uuid)}?reason=${encodeURIComponent(reason)}`, signal);
+}

package/src/resources/report-section/report-sections.api.ts

@@ -0,0 +1,73 @@
+import { omrsGet, omrsPost } from '../openmrs-api';
+import { decodeHtmlEntities } from '../../utils/html-entities.utils';
+
+/**
+ * REST resource:
+ *  /ws/rest/v1/reportbuildersection
+ */
+const RESOURCE = '/reportbuilder/section';
+
+type RestList<T> = { results?: T[] } & Record<string, any>;
+
+function unwrapRestList<T>(data: RestList<T> | T[] | undefined): T[] {
+  if (!data) return [];
+  if (Array.isArray(data)) return data;
+  return Array.isArray(data.results) ? data.results : [];
+}
+
+export type RestRep = 'default' | 'full';
+
+export type ReportSectionDto = {
+  uuid: string;
+  name: string;
+  description?: string;
+  code?: string;
+  configJson?: string;
+  metaJson?: string;
+  retired?: boolean;
+};
+
+function normalizeSectionDto(s: ReportSectionDto): ReportSectionDto {
+  return {
+    ...s,
+    configJson: s.configJson ? decodeHtmlEntities(s.configJson) : s.configJson,
+    metaJson: s.metaJson ? decodeHtmlEntities(s.metaJson) : s.metaJson,
+  };
+}
+
+export type ListSectionsParams = {
+  q?: string;
+  includeRetired?: boolean;
+  v?: RestRep;
+};
+
+export async function listSections(params?: ListSectionsParams, signal?: AbortSignal): Promise<ReportSectionDto[]> {
+  const q = params?.q?.trim();
+  const includeRetired = params?.includeRetired === true;
+  const v = params?.v ?? 'default';
+
+  const qs = new URLSearchParams();
+  qs.set('v', v);
+  if (q) qs.set('q', q);
+  if (includeRetired) qs.set('includeRetired', 'true');
+
+  const data = await omrsGet<RestList<ReportSectionDto> | ReportSectionDto[] | undefined>(`${RESOURCE}?${qs.toString()}`, signal);
+  return unwrapRestList(data)
+    .filter((x) => Boolean(x?.uuid))
+    .map(normalizeSectionDto);
+}
+
+export async function getSection(uuid: string, signal?: AbortSignal, v: RestRep = 'full'): Promise<ReportSectionDto> {
+  const s = await omrsGet<ReportSectionDto>(`${RESOURCE}/${encodeURIComponent(uuid)}?v=${v}`, signal);
+  return normalizeSectionDto(s);
+}
+
+export async function createSection(payload: Partial<ReportSectionDto>, signal?: AbortSignal): Promise<ReportSectionDto> {
+  const s = await omrsPost<ReportSectionDto>(RESOURCE, payload, signal);
+  return normalizeSectionDto(s);
+}
+
+export async function updateSection(uuid: string, payload: Partial<ReportSectionDto>, signal?: AbortSignal): Promise<ReportSectionDto> {
+  const s = await omrsPost<ReportSectionDto>(`${RESOURCE}/${encodeURIComponent(uuid)}`, payload, signal);
+  return normalizeSectionDto(s);
+}

package/src/resources/report-section/section-preview.api.ts

@@ -0,0 +1,25 @@
+import { openmrsFetch } from '@openmrs/esm-framework';
+
+import { guardRejection } from '../../utils/api-error.utils';
+
+export type SectionPreviewRequest = {
+  sectionUuid: string;
+  indicatorUuid?: string;
+  startDate: string;
+  endDate: string;
+  maxRows?: number;
+  params?: Record<string, any>;
+};
+
+export async function previewSection(body: SectionPreviewRequest, signal?: AbortSignal) {
+  const { data } = await guardRejection(
+    openmrsFetch('/ws/rest/v1/reportbuilder/sectionpreview', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body,
+      signal,
+    }),
+  );
+
+  return data;
+}

package/src/resources/theme/data-theme.api.ts

@@ -0,0 +1,88 @@
+import type { DataTheme } from '../../types/theme/data-theme.types';
+import { omrsDelete, omrsGet, omrsPost } from '../openmrs-api';
+
+const RESOURCE = '/reportbuilder/datatheme';
+
+type RestList<T> = {
+    results?: T[];
+} & Record<string, any>;
+
+function unwrapRestList<T>(data: RestList<T> | T[] | undefined): T[] {
+    if (!data) return [];
+    if (Array.isArray(data)) return data;
+    return Array.isArray(data.results) ? data.results : [];
+}
+
+export async function listThemes(q?: string, signal?: AbortSignal): Promise<DataTheme[]> {
+    const trimmed = q?.trim();
+    const path = trimmed
+        ? `${RESOURCE}?q=${encodeURIComponent(trimmed)}&v=full`
+        : `${RESOURCE}?v=full`;
+
+    const data = await omrsGet<RestList<DataTheme> | DataTheme[] | undefined>(path, signal);
+    return unwrapRestList(data);
+}
+
+export async function getTheme(uuid: string, signal?: AbortSignal): Promise<DataTheme> {
+    return omrsGet<DataTheme>(`${RESOURCE}/${encodeURIComponent(uuid)}?v=full`, signal);
+}
+
+export async function createTheme(
+    payload: Partial<DataTheme>,
+    signal?: AbortSignal
+): Promise<DataTheme> {
+    return omrsPost<DataTheme>(RESOURCE, payload, signal);
+}
+
+export async function updateTheme(
+    uuid: string,
+    payload: Partial<DataTheme>,
+    signal?: AbortSignal
+): Promise<DataTheme> {
+    // RESTWS often uses POST for update
+    return omrsPost<DataTheme>(`${RESOURCE}/${encodeURIComponent(uuid)}`, payload, signal);
+}
+
+export async function deleteTheme(
+    uuid: string,
+    purge = false,
+    reason = 'Retired via UI',
+    signal?: AbortSignal
+): Promise<void> {
+    const qs = purge
+        ? `purge=true`
+        : `purge=false&reason=${encodeURIComponent(reason)}`;
+
+    await omrsDelete<void>(`${RESOURCE}/${encodeURIComponent(uuid)}?${qs}`, signal);
+}
+
+export type DataThemeDto = {
+    uuid: string;
+    name: string;
+    description?: string;
+    code?: string;
+    domain?: string;
+    configJson?: string; // stringified JSON
+    metaJson?: string; // stringified JSON
+    retired?: boolean;
+};
+
+type ListResponse = { results: DataThemeDto[] } | DataThemeDto[];
+
+function normalizeList(payload: ListResponse): DataThemeDto[] {
+    if (Array.isArray(payload)) return payload;
+    return payload?.results ?? [];
+}
+
+export async function listDataThemes(q?: string, signal?: AbortSignal): Promise<DataThemeDto[]> {
+    const trimmed = q?.trim();
+    const path = trimmed
+        ? `${RESOURCE}?q=${encodeURIComponent(trimmed)}&v=full`
+        : `${RESOURCE}?v=full`;
+    const data = await omrsGet<ListResponse>(path, signal);
+    return normalizeList(data);
+}
+
+export async function getDataTheme(uuid: string, signal?: AbortSignal): Promise<DataThemeDto> {
+    return omrsGet<DataThemeDto>(`${RESOURCE}/${uuid}?v=full`, signal);
+}

package/src/resources/theme/etl-schema.api.ts

@@ -0,0 +1,101 @@
+import { omrsGet } from '../openmrs-api';
+
+export type SchemaTable = {
+    name: string;
+    /** legacy field kept for older consumers */
+    type?: string;
+    /** approximate INFORMATION_SCHEMA row count; null for views */
+    rows?: number | null;
+    /** last modification time as serialized by OpenMRS; null when unknown */
+    updateTime?: string | null;
+    /** "BASE TABLE" or "VIEW" */
+    tableType?: string | null;
+};
+
+type RawTable = Record<string, any>;
+
+type ListTablesResponse =
+    | { results: SchemaTable[]; totalCount?: number }
+    | { tables: SchemaTable[] }
+    | SchemaTable[]
+    | string[];
+
+/**
+ * Normalize one table entry from any known backend shape into a SchemaTable.
+ */
+function normalizeTable(entry: RawTable | string): SchemaTable {
+    if (typeof entry === 'string') return { name: entry };
+    return {
+        name: String(entry?.name ?? entry?.tableName ?? entry?.table ?? ''),
+        type: entry?.type,
+        rows: typeof entry?.rows === 'number' ? entry.rows
+            : typeof entry?.tableRows === 'number' ? entry.tableRows
+            : null,
+        updateTime: entry?.updateTime ?? null,
+        tableType: entry?.tableType ?? entry?.type ?? null,
+    };
+}
+
+/**
+ * Normalize a tables payload from any known backend shape.
+ * Exported for tests.
+ */
+export function normalizeTables(payload: ListTablesResponse | null | undefined): SchemaTable[] {
+    if (!payload) return [];
+
+    let raw: Array<RawTable | string> = [];
+    if (Array.isArray(payload)) {
+        raw = payload;
+    } else {
+        const anyPayload: any = payload;
+        if (Array.isArray(anyPayload?.results)) raw = anyPayload.results;
+        else if (Array.isArray(anyPayload?.tables)) raw = anyPayload.tables;
+    }
+
+    return raw
+        .map(normalizeTable)
+        .filter((t) => Boolean(t.name));
+}
+
+/** RESTWS rejects limit > 100 ("absolute limit"); page in chunks of this size. */
+const PAGE_SIZE = 100;
+/** Safety cap: at most 30 pages (3000 tables) per full load. */
+const MAX_PAGES = 30;
+
+/**
+ * Fetch all ETL tables with row-count metadata, paging through RESTWS in
+ * <=100-row chunks (the REST absolute limit) until totalCount is reached.
+ */
+export async function getSchemaTables(signal?: AbortSignal): Promise<SchemaTable[]> {
+    const all: SchemaTable[] = [];
+    const seen = new Set<string>();
+    let totalCount: number | null = null;
+
+    for (let page = 0; page < MAX_PAGES; page++) {
+        if (signal?.aborted) return [];
+        const startIndex = page * PAGE_SIZE;
+        const data = await omrsGet<ListTablesResponse>(
+            `/reportbuilder/schema?limit=${PAGE_SIZE}&startIndex=${startIndex}&totalCount=true`,
+            signal,
+        );
+
+        const results = normalizeTables(data);
+        for (const table of results) {
+            if (!seen.has(table.name)) {
+                seen.add(table.name);
+                all.push(table);
+            }
+        }
+
+        if (totalCount === null) {
+            const anyData: any = data;
+            totalCount = typeof anyData?.totalCount === 'number' ? anyData.totalCount : null;
+        }
+
+        // Stop on a short page, once we have everything, or if totalCount is unknown
+        if (results.length < PAGE_SIZE) break;
+        if (totalCount !== null && all.length >= totalCount) break;
+    }
+
+    return all;
+}

package/src/resources/theme/etl-table-meta.api.ts

@@ -0,0 +1,45 @@
+import { omrsGet } from '../openmrs-api';
+
+export type TableColumn = {
+  name: string;
+  type?: string;
+  nullable?: boolean;
+};
+
+type RawColumn = {
+  columnName?: string;
+  dataType?: string;
+  name?: string;      // in case backend changes later
+  type?: string;
+  nullable?: boolean;
+};
+
+type RawMetaResponse =
+    | { results?: RawColumn[] }
+    | { columns?: RawColumn[] }
+    | RawColumn[];
+
+function normalizeColumns(input: RawColumn[] = []): TableColumn[] {
+  return input
+      .map((c) => ({
+        name: c.name ?? c.columnName ?? '',
+        type: c.type ?? c.dataType,
+        nullable: c.nullable,
+      }))
+      .filter((c) => c.name.length > 0);
+}
+
+export async function getETLTableMeta(
+    table: string,
+    signal?: AbortSignal
+): Promise<TableColumn[]> {
+  const data = await omrsGet<RawMetaResponse>(
+      `/etltablecolumn?table=${encodeURIComponent(table)}`,
+      signal
+  );
+
+  if (Array.isArray(data)) return normalizeColumns(data);
+
+  const anyData = data as any;
+  return normalizeColumns(anyData?.columns ?? anyData?.results ?? []);
+}

package/src/root.component.tsx

@@ -0,0 +1,20 @@
+import React from 'react';
+import { BrowserRouter, Route, Routes, Navigate } from 'react-router-dom';
+
+import ReportBuilderRoutes from './routes/report-builder.routes';
+
+const RootComponent: React.FC = () => {
+    return (
+        <BrowserRouter basename={`${window.spaBase}/report-builder`}>
+            <Routes>
+                {/* All report-builder routes live under the shell (left nav + content frame) */}
+                <Route path="/*" element={<ReportBuilderRoutes />} />
+
+                {/* Safety fallback */}
+                <Route path="*" element={<Navigate to="/" replace />} />
+            </Routes>
+        </BrowserRouter>
+    );
+};
+
+export default RootComponent;