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

package/src/resources/location/location.api.ts

@@ -0,0 +1,135 @@
+/**
+ * Location API
+ *
+ * OpenMRS REST API for locations
+ * GET /ws/rest/v1/location
+ */
+
+import { omrsGet } 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 : [];
+}
+
+export type LocationDto = {
+  uuid: string;
+  display: string;
+  name: string;
+  description?: string;
+  country?: string;
+  stateProvince?: string;
+  countyDistrict?: string;
+  address3?: string;
+  address2?: string;
+  address1?: string;
+  cityVillage?: string;
+  postalCode?: string;
+  latitude?: string;
+  longitude?: string;
+  altitude?: string;
+  tags?: Array<{
+    uuid: string;
+    display: string;
+  }>;
+  parentLocation?: {
+    uuid: string;
+    display: string;
+    name: string;
+  };
+  childLocations?: LocationDto[];
+  retired?: boolean;
+};
+
+/**
+ * List all locations
+ * @param includeAll - Include retired locations
+ * @param tagUuid - Filter by location tag UUID
+ * @param signal - AbortSignal for request cancellation
+ */
+export async function listLocations(
+  includeAll: boolean = false,
+  tagUuid?: string,
+  signal?: AbortSignal
+): Promise<Array<LocationDto>> {
+  const params = new URLSearchParams();
+  params.append('v', 'full');
+  if (includeAll) {
+    params.append('includeAll', 'true');
+  }
+  if (tagUuid) {
+    params.append('tag', tagUuid);
+  }
+
+  const qs = params.toString();
+  const data = await omrsGet<RestList<LocationDto> | LocationDto[] | undefined>(
+    `location?${qs}`,
+    signal
+  );
+  return unwrapRestList(data);
+}
+
+/**
+ * Get a location by UUID
+ * @param uuid - Location UUID
+ * @param signal - AbortSignal for request cancellation
+ */
+export async function getLocation(uuid: string, signal?: AbortSignal): Promise<LocationDto> {
+  return omrsGet<LocationDto>(`location/${uuid}?v=full`, signal);
+}
+
+/**
+ * Search locations by name
+ * @param query - Search term (location name)
+ * @param tagUuid - Filter by location tag UUID
+ * @param signal - AbortSignal for request cancellation
+ */
+export async function searchLocations(
+  query: string,
+  tagUuid?: string,
+  signal?: AbortSignal
+): Promise<Array<LocationDto>> {
+  if (!query?.trim()) {
+    return [];
+  }
+
+  const params = new URLSearchParams();
+  params.append('q', query);
+  params.append('v', 'full');
+  if (tagUuid) {
+    params.append('tag', tagUuid);
+  }
+
+  const qs = params.toString();
+  const data = await omrsGet<RestList<LocationDto> | LocationDto[] | undefined>(
+    `location?${qs}`,
+    signal
+  );
+  return unwrapRestList(data);
+}
+
+/**
+ * Get location tree (locations with hierarchy)
+ * @param rootUuid - Root location UUID to start from (optional)
+ * @param signal - AbortSignal for request cancellation
+ */
+export async function getLocationTree(
+  rootUuid?: string,
+  signal?: AbortSignal
+): Promise<Array<LocationDto>> {
+  const params = new URLSearchParams();
+  params.append('v', 'full');
+  if (rootUuid) {
+    params.append('ancestorOf', rootUuid);
+  }
+
+  const qs = params.toString();
+  const data = await omrsGet<RestList<LocationDto> | LocationDto[] | undefined>(
+    `location?${qs}`,
+    signal
+  );
+  return unwrapRestList(data);
+}

package/src/resources/openmrs-api.ts

@@ -0,0 +1,40 @@
+import { openmrsFetch, restBaseUrl } from '@openmrs/esm-framework';
+
+import { normalizeApiError } from '../utils/api-error.utils';
+
+async function run<T>(request: () => Promise<T>): Promise<T> {
+    try {
+        return await request();
+    } catch (error) {
+        throw normalizeApiError(error);
+    }
+}
+
+export async function omrsGet<T>(path: string, signal?: AbortSignal): Promise<T> {
+    return run(async () => {
+        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> {
+    return run(async () => {
+        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> {
+    return run(async () => {
+        const url = `${restBaseUrl}${path.startsWith('/') ? path : `/${path}`}`;
+        const res = await openmrsFetch<T>(url, { method: 'DELETE', signal });
+        return res.data;
+    });
+}

package/src/resources/patient-identifier-type/patient-identifier-type.api.ts

@@ -0,0 +1,65 @@
+/**
+ * Patient Identifier Type API
+ *
+ * OpenMRS REST API for patient identifier types
+ * GET /ws/rest/v1/patientidentifiertype
+ */
+
+import { omrsGet } 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 : [];
+}
+
+export type PatientIdentifierTypeDto = {
+  uuid: string;
+  display: string;
+  name?: string;
+  description?: string;
+  format?: string;
+  formatDescription?: string;
+  required?: boolean;
+  checkDigit?: boolean;
+  validator?: string;
+  locationBehavior?: 'REQUIRED' | 'NOT_USED';
+  uniquenessBehavior?: 'UNIQUE' | 'NON_UNIQUE' | 'LOCATION';
+  retired?: boolean;
+};
+
+/**
+ * List all patient identifier types
+ */
+export async function listPatientIdentifierTypes(includeAll: boolean = false, signal?: AbortSignal): Promise<Array<PatientIdentifierTypeDto>> {
+  const qs = includeAll ? '?includeAll=true&v=default' : '?v=default';
+  const data = await omrsGet<RestList<PatientIdentifierTypeDto> | PatientIdentifierTypeDto[] | undefined>(
+    `patientidentifiertype${qs}`,
+    signal
+  );
+  return unwrapRestList(data);
+}
+
+/**
+ * Get a patient identifier type by UUID
+ */
+export async function getPatientIdentifierType(uuid: string, signal?: AbortSignal): Promise<PatientIdentifierTypeDto> {
+  return omrsGet<PatientIdentifierTypeDto>(`patientidentifiertype/${uuid}?v=default`, signal);
+}
+
+/**
+ * Search patient identifier types by name
+ */
+export async function searchPatientIdentifierTypes(query: string, signal?: AbortSignal): Promise<Array<PatientIdentifierTypeDto>> {
+  if (!query?.trim()) {
+    return [];
+  }
+
+  const data = await omrsGet<RestList<PatientIdentifierTypeDto> | PatientIdentifierTypeDto[] | undefined>(
+    `patientidentifiertype?q=${encodeURIComponent(query)}&v=default`,
+    signal
+  );
+  return unwrapRestList(data);
+}

package/src/resources/person-attribute-type/person-attribute-type.api.ts

@@ -0,0 +1,71 @@
+/**
+ * Person Attribute Type API
+ *
+ * OpenMRS REST API for person attribute types
+ * GET /ws/rest/v1/personattributetype
+ */
+
+import { omrsGet } 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 : [];
+}
+
+export type PersonAttributeTypeDto = {
+  uuid: string;
+  display: string;
+  name?: string;
+  description?: string;
+  format?: string;
+  foreignKey?: number;
+  sortWeight?: number;
+  searchable?: boolean;
+  editPrivilege?: string;
+  retired?: boolean;
+  // Full representation includes the concept for format="org.openmrs.Concept"
+  concept?: {
+    uuid: string;
+    display: string;
+    name: {
+      name: string;
+    };
+  };
+};
+
+/**
+ * List all person attribute types
+ */
+export async function listPersonAttributeTypes(includeAll: boolean = false, signal?: AbortSignal): Promise<Array<PersonAttributeTypeDto>> {
+  const qs = includeAll ? '?includeAll=true&v=default' : '?v=default';
+  const data = await omrsGet<RestList<PersonAttributeTypeDto> | PersonAttributeTypeDto[] | undefined>(
+    `personattributetype${qs}`,
+    signal
+  );
+  return unwrapRestList(data);
+}
+
+/**
+ * Get a person attribute type by UUID
+ */
+export async function getPersonAttributeType(uuid: string, signal?: AbortSignal): Promise<PersonAttributeTypeDto> {
+  return omrsGet<PersonAttributeTypeDto>(`personattributetype/${uuid}?v=default`, signal);
+}
+
+/**
+ * Search person attribute types by name
+ */
+export async function searchPersonAttributeTypes(query: string, signal?: AbortSignal): Promise<Array<PersonAttributeTypeDto>> {
+  if (!query?.trim()) {
+    return [];
+  }
+
+  const data = await omrsGet<RestList<PersonAttributeTypeDto> | PersonAttributeTypeDto[] | undefined>(
+    `personattributetype?q=${encodeURIComponent(query)}&v=default`,
+    signal
+  );
+  return unwrapRestList(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,140 @@
+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;
+    reportType?: 'AGGREGATE' | 'LINE_LIST';
+    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;
+    category?: string; // Optional category UUID/name to add report to library
+};
+
+export type CompileReportResult = {
+    reportUuid: string;
+    reportDefinitionUuid?: string;
+    reportDefinitionName?: string;
+    reportDesignPath?: string;
+    compiled?: boolean;
+    addedToLibrary?: boolean;
+    reportLibraryUuid?: string;
+};
+
+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))
+        .filter((x) => {
+          // Exclude LINE_LIST reports - only show AGGREGATE reports in the reports dashboard
+          const reportType = (x as any)?.reportType;
+          if (reportType === 'LINE_LIST') return false;
+
+          // Also check configJson for type if reportType is not set
+          if (x.configJson) {
+            try {
+              const config = JSON.parse(x.configJson);
+              if (config?.type === 'LINE_LIST') return false;
+            } catch (e) {
+              // Ignore parsing errors
+            }
+          }
+
+          return true;
+        })
+        .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,
+    category?: string,
+    signal?: AbortSignal,
+): Promise<CompileReportResult> {
+    const payload: CompileReportPayload = { reportUuid, category };
+    console.log('compileReport sending:', payload);
+    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);
+}