@epcare/esm-report-builder 0.1.1-pre.13

package/src/resources/concepts/concepts.resource.ts

@@ -0,0 +1,44 @@
+import type { ConceptSummary } from './concept-types';
+
+import { omrsGet } from '../openmrs-api';
+
+
+const RESOURCE = '/concept';
+const cutomConceptRepresentation = 'custom:(id,uuid,display,datatype:(uuid,name),conceptClass:(uuid,name),answers:(id,uuid,display),mappings:(display,uuid,conceptMapType:(display)))';
+
+type ConceptSearchResponse = {
+    results: ConceptSummary[];
+};
+
+type ConceptAnswersResponse = {
+    answers?: Array<{ uuid: string; display: string; id?: number; mappings?: any[]; conceptClass?: any; datatype?: any }>;
+};
+
+export async function searchConcepts(
+    query: string,
+    signal?: AbortSignal,
+): Promise<ConceptSummary[]> {
+    const res = await omrsGet<ConceptSearchResponse>(
+        `${RESOURCE}/?q=${encodeURIComponent(query)}&v=${cutomConceptRepresentation}`,
+        signal);
+
+    return res?.results ?? [];
+}
+
+export async function getConceptByUuid(uuid: string, signal?: AbortSignal): Promise<ConceptSummary> {
+    const u = String(uuid ?? '').trim();
+    if (!u) {
+        throw new Error('Concept uuid is required');
+    }
+
+    // /concept/{uuid} returns a single Concept object
+    return omrsGet<ConceptSummary>(`${RESOURCE}/${encodeURIComponent(u)}?v=${cutomConceptRepresentation}`, signal);
+}
+
+
+export async function getConceptAnswers(questionUuid: string, signal?: AbortSignal): Promise<ConceptSummary[]> {
+    const res = await omrsGet<ConceptAnswersResponse>(`${RESOURCE}/${questionUuid}?v=${cutomConceptRepresentation}`, signal );
+
+    const answers = (res as any)?.answers ?? [];
+    return answers as ConceptSummary[];
+}

package/src/resources/concepts/useConceptSearch.ts

@@ -0,0 +1,41 @@
+import { useState, useEffect } from 'react';
+import { searchConcepts } from './concepts.resource';
+import type { ConceptSummary } from './concept-types';
+
+export function useConceptSearch(query: string) {
+    const [loading, setLoading] = useState(false);
+    const [results, setResults] = useState<ConceptSummary[]>([]);
+    const [error, setError] = useState<string | null>(null);
+
+    useEffect(() => {
+        const q = query.trim();
+        if (q.length < 2) {
+            setResults([]);
+            setError(null);
+            return;
+        }
+
+        const ctrl = new AbortController();
+
+        const t = window.setTimeout(async () => {
+            try {
+                setLoading(true);
+                setError(null);
+
+                const res = await searchConcepts(q, ctrl.signal); // ✅ returns ConceptSummary[]
+                setResults(res);
+            } catch (e: any) {
+                if (e?.name !== 'AbortError') setError('Failed to search concepts');
+            } finally {
+                setLoading(false);
+            }
+        }, 300);
+
+        return () => {
+            ctrl.abort();
+            window.clearTimeout(t);
+        };
+    }, [query]);
+
+    return { loading, results, error };
+}

package/src/resources/etl-source/etl-source.api.ts

@@ -0,0 +1,65 @@
+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/etlsource';
+
+export type ETLSourceDto = {
+  uuid: string;
+  display?: string;
+  name: string;
+  code?: string;
+  description?: string;
+  tablePatterns?: string;
+  schemaName?: string;
+  sourceType?: string;
+  active?: boolean;
+  voided?: boolean;
+};
+
+export type SaveETLSourcePayload = {
+  name: string;
+  code?: string;
+  description?: string;
+  tablePatterns?: string;
+  schemaName?: string;
+  sourceType?: string;
+  active?: boolean;
+};
+
+export async function listETLSources(q?: string, signal?: AbortSignal): Promise<ETLSourceDto[]> {
+  const qs = new URLSearchParams();
+  qs.set('v', 'custom:(uuid,name,code,description,tablePatterns,schemaName,sourceType,active,retired)');
+  if (q?.trim()) qs.set('q', q.trim());
+
+  const data = await omrsGet<RestList<ETLSourceDto> | ETLSourceDto[] | undefined>(
+    `${RESOURCE}?${qs.toString()}`,
+    signal,
+  );
+
+  return unwrapRestList(data).filter((x) => Boolean(x?.uuid));
+}
+
+export async function createETLSource(payload: SaveETLSourcePayload, signal?: AbortSignal) {
+  return omrsPost<ETLSourceDto>(RESOURCE, payload, signal);
+}
+
+export async function updateETLSource(uuid: string, payload: SaveETLSourcePayload, signal?: AbortSignal) {
+  return omrsPost<ETLSourceDto>(`${RESOURCE}/${encodeURIComponent(uuid)}`, payload, signal);
+}
+
+export async function deleteETLSource(
+  uuid: string,
+  reason = 'Retired from Report Builder Admin',
+  signal?: AbortSignal,
+) {
+  const qs = new URLSearchParams();
+  qs.set('reason', reason);
+  return omrsDelete(`${RESOURCE}/${encodeURIComponent(uuid)}?${qs.toString()}`, signal);
+}

package/src/resources/indicator/indicators.api.ts

@@ -0,0 +1,125 @@
+import { omrsDelete, omrsGet, omrsPost } from '../openmrs-api';
+import { decodeHtmlEntities } from '../../utils/html-entities.utils';
+
+/**
+ * REST resource:
+ *  /ws/rest/v1/reportbuilderindicator
+ */
+const RESOURCE = '/reportbuilder/indicator';
+
+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 : [];
+}
+
+function normalizeIndicatorDto(ind: IndicatorDto): IndicatorDto {
+    // OpenMRS can return HTML-escaped strings; decode before UI uses them.
+    return {
+        ...ind,
+        configJson: ind.configJson ? decodeHtmlEntities(ind.configJson) : ind.configJson,
+        metaJson: ind.metaJson ? decodeHtmlEntities(ind.metaJson) : ind.metaJson,
+        sqlTemplate: ind.sqlTemplate ? decodeHtmlEntities(ind.sqlTemplate) : ind.sqlTemplate,
+        denominatorSqlTemplate: ind.denominatorSqlTemplate
+            ? decodeHtmlEntities(ind.denominatorSqlTemplate)
+            : ind.denominatorSqlTemplate,
+    };
+}
+
+export type IndicatorKind = 'BASE' | 'COMPOSITE' | 'FINAL';
+export type IndicatorValueType = 'NUMBER' | 'TABLE' | 'PATIENT_SET';
+export type RestRep = 'default' | 'full';
+
+export type IndicatorDto = {
+    uuid: string;
+    name: string;
+    description?: string;
+    code?: string;
+
+    kind: IndicatorKind;
+    defaultValueType?: IndicatorValueType;
+
+    // new-ish fields you’re adding backend-side (safe optional)
+    themeUuid?: string | null;
+    configJson?: string;
+    metaJson?: string;
+    sqlTemplate?: string | null;
+    denominatorSqlTemplate?: string | null;
+
+    retired?: boolean;
+    retireReason?: string | null;
+};
+
+export type MambaIndicatorDto = {
+    id: string,
+    uuid: string;
+    name: string;
+    description?: string;
+    code?: string;
+
+    kind: IndicatorKind;
+    defaultValueType?: IndicatorValueType;
+    themeName?: string;
+    themeColor?: string;
+
+    // new-ish fields you’re adding backend-side (safe optional)
+    themeUuid?: string | null;
+    configJson?: string;
+    metaJson?: string;
+    sqlTemplate?: string | null;
+    denominatorSqlTemplate?: string | null;
+
+    retired?: boolean;
+    retireReason?: string | null;
+};
+
+export type ListIndicatorsParams = {
+    q?: string;
+    kind?: IndicatorKind;
+    includeRetired?: boolean;
+    v?: RestRep;
+};
+
+export async function listIndicators(params?: ListIndicatorsParams, signal?: AbortSignal): Promise<IndicatorDto[]> {
+    const q = params?.q?.trim();
+    const kind = params?.kind?.trim?.() ? params.kind : params?.kind;
+    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 (kind) qs.set('kind', kind);
+    if (includeRetired) qs.set('includeRetired', 'true');
+
+    const data = await omrsGet<RestList<IndicatorDto> | IndicatorDto[] | undefined>(`${RESOURCE}?${qs.toString()}`, signal);
+
+    return unwrapRestList(data)
+        .filter((x) => Boolean(x?.uuid))
+        .map(normalizeIndicatorDto);
+}
+
+export async function getIndicator(uuid: string, signal?: AbortSignal, v: RestRep = 'full'): Promise<IndicatorDto> {
+    const res = await omrsGet<IndicatorDto>(`${RESOURCE}/${encodeURIComponent(uuid)}?v=${v}`, signal);
+    return normalizeIndicatorDto(res);
+}
+
+export async function createIndicator(payload: Partial<IndicatorDto>, signal?: AbortSignal): Promise<IndicatorDto> {
+    return omrsPost<IndicatorDto>(RESOURCE, payload, signal);
+}
+
+export async function updateIndicator(uuid: string, payload: Partial<IndicatorDto>, signal?: AbortSignal): Promise<IndicatorDto> {
+    return omrsPost<IndicatorDto>(`${RESOURCE}/${encodeURIComponent(uuid)}`, payload, signal);
+}
+
+export async function deleteIndicator(
+    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);
+}

package/src/resources/openmrs-api.ts

@@ -0,0 +1,24 @@
+import { openmrsFetch, restBaseUrl } from '@openmrs/esm-framework';
+
+export async function omrsGet<T>(path: string, signal?: AbortSignal): Promise<T> {
+    const url = `${restBaseUrl}${path.startsWith('/') ? path : `/${path}`}`;
+    const res = await openmrsFetch<T>(url, { signal });
+    return res.data;
+}
+
+export async function omrsPost<T>(path: string, body: any, signal?: AbortSignal): Promise<T> {
+    const url = `${restBaseUrl}${path.startsWith('/') ? path : `/${path}`}`;
+    const res = await openmrsFetch<T>(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body,
+        signal,
+    });
+    return res.data;
+}
+
+export async function omrsDelete<T>(path: string, signal?: AbortSignal): Promise<T> {
+    const url = `${restBaseUrl}${path.startsWith('/') ? path : `/${path}`}`;
+    const res = await openmrsFetch<T>(url, { method: 'DELETE', signal });
+    return res.data;
+}

package/src/resources/preview/sql-preview.api.ts

@@ -0,0 +1,54 @@
+export type SqlPreviewRequest = {
+    /**
+     * Prefer plain sql for now.
+     * If you later add sqlEncoded, you can extend this type.
+     */
+    sql: string;
+    params?: Record<string, any>;
+    maxRows?: number;
+};
+
+export type SqlPreviewResponse = {
+    columns: string[];
+    rows: any[][];
+    rowCount: number;
+    truncated: boolean;
+
+    // optional echo fields from RESTWS
+    sql?: string;
+    params?: Record<string, any>;
+    maxRows?: number;
+    resourceVersion?: string;
+};
+
+function restBase() {
+    // OpenMRS ESM convention
+    const base = (window as any).openmrsBaseUrl ?? '/openmrs/';
+    return `${base}ws/rest/v1`;
+}
+
+export async function previewSql(request: SqlPreviewRequest, signal?: AbortSignal): Promise<SqlPreviewResponse> {
+    const url = `${restBase()}/reportbuilder/sqlpreview`;
+
+    const res = await fetch(url, {
+        method: 'POST',
+        credentials: 'include',
+        headers: {
+            'Content-Type': 'application/json',
+            Accept: 'application/json',
+        },
+        body: JSON.stringify({
+            sql: request.sql,
+            params: request.params ?? {},
+            maxRows: request.maxRows ?? 200,
+        }),
+        signal,
+    });
+
+    if (!res.ok) {
+        const text = await res.text().catch(() => '');
+        throw new Error(`SQL preview failed (${res.status}). ${text}`);
+    }
+
+    return (await res.json()) as SqlPreviewResponse;
+}

package/src/resources/report/reports.api.ts

@@ -0,0 +1,117 @@
+import { omrsGet, omrsPost } from '../openmrs-api';
+import { decodeHtmlEntities } from '../../utils/html-entities.utils';
+
+const RESOURCE = '/reportbuilder/report';
+const COMPILE_RESOURCE = '/reportbuilder/reportcompile';
+
+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 ReportDto = {
+    uuid: string;
+    name: string;
+    description?: string;
+    code?: string;
+    configJson?: string;
+    metaJson?: string;
+    retired?: boolean;
+};
+
+export type SaveReportPayload = {
+    name: string;
+    description?: string;
+    code?: string;
+    configJson?: string;
+    metaJson?: string;
+};
+
+export type ListReportsParams = {
+    q?: string;
+    includeRetired?: boolean;
+    v?: RestRep;
+};
+
+export type CompileReportPayload = {
+    reportUuid: string;
+};
+
+export type CompileReportResult = {
+    reportUuid: string;
+    reportDefinitionUuid?: string;
+    reportDefinitionName?: string;
+    reportDesignPath?: string;
+    compiled?: boolean;
+};
+
+function normalizeReportDto(r: ReportDto): ReportDto {
+    return {
+        ...r,
+        configJson: r.configJson ? decodeHtmlEntities(r.configJson) : r.configJson,
+        metaJson: r.metaJson ? decodeHtmlEntities(r.metaJson) : r.metaJson,
+    };
+}
+
+export async function listReports(
+    params?: ListReportsParams,
+    signal?: AbortSignal,
+): Promise<ReportDto[]> {
+    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<ReportDto> | ReportDto[] | undefined>(
+        `${RESOURCE}?${qs.toString()}`,
+        signal,
+    );
+
+    return unwrapRestList(data)
+        .filter((x) => Boolean(x?.uuid))
+        .map(normalizeReportDto);
+}
+
+export async function getReport(
+    uuid: string,
+    signal?: AbortSignal,
+    v: RestRep = 'full',
+): Promise<ReportDto> {
+    const data = await omrsGet<ReportDto>(`${RESOURCE}/${encodeURIComponent(uuid)}?v=${v}`, signal);
+    return normalizeReportDto(data);
+}
+
+export async function createReport(
+    payload: SaveReportPayload,
+    signal?: AbortSignal,
+): Promise<ReportDto> {
+    const data = await omrsPost<ReportDto>(RESOURCE, payload, signal);
+    return normalizeReportDto(data);
+}
+
+export async function updateReport(
+    uuid: string,
+    payload: SaveReportPayload,
+    signal?: AbortSignal,
+): Promise<ReportDto> {
+    const data = await omrsPost<ReportDto>(`${RESOURCE}/${encodeURIComponent(uuid)}`, payload, signal);
+    return normalizeReportDto(data);
+}
+
+export async function compileReport(
+    reportUuid: string,
+    signal?: AbortSignal,
+): Promise<CompileReportResult> {
+    const payload: CompileReportPayload = { reportUuid };
+    return omrsPost<CompileReportResult>(COMPILE_RESOURCE, payload, signal);
+}

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

@@ -0,0 +1,41 @@
+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/reportcategory';
+
+export type ReportCategoryDto = {
+  uuid: string;
+  display?: string;
+  name: string;
+  description?: string;
+  retired?: boolean;
+};
+
+export async function listReportCategories(q?: string, signal?: AbortSignal): Promise<ReportCategoryDto[]> {
+  const qs = new URLSearchParams();
+  qs.set('v', 'full');
+  if (q?.trim()) qs.set('q', q.trim());
+  const data = await omrsGet<RestList<ReportCategoryDto> | ReportCategoryDto[] | undefined>(`${RESOURCE}?${qs.toString()}`, signal);
+  return unwrapRestList(data).filter((x) => Boolean(x?.uuid));
+}
+
+export async function createReportCategory(payload: Pick<ReportCategoryDto, 'name' | 'description'>, signal?: AbortSignal) {
+  return omrsPost<ReportCategoryDto>(RESOURCE, payload, signal);
+}
+
+export async function updateReportCategory(uuid: string, payload: Pick<ReportCategoryDto, 'name' | 'description'>, signal?: AbortSignal) {
+  return omrsPost<ReportCategoryDto>(`${RESOURCE}/${encodeURIComponent(uuid)}`, payload, signal);
+}
+
+export async function deleteReportCategory(uuid: string, reason = 'Retired from Report Builder Admin', signal?: AbortSignal) {
+  const qs = new URLSearchParams();
+  qs.set('reason', reason);
+  return omrsDelete<any>(`${RESOURCE}/${encodeURIComponent(uuid)}?${qs.toString()}`, signal);
+}

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,21 @@
+import { openmrsFetch } from '@openmrs/esm-framework';
+
+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 openmrsFetch('/ws/rest/v1/reportbuilder/sectionpreview', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body,
+    signal,
+  });
+
+  return data;
+}