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

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/mamba-schema.api.ts

@@ -0,0 +1,31 @@
+import { omrsGet } from '../openmrs-api';
+
+export type SchemaTable = { name: string; type?: string };
+
+type ListTablesResponse =
+    | { results: SchemaTable[] }
+    | { tables: SchemaTable[] }
+    | SchemaTable[]
+    | string[];
+
+function normalizeTables(payload: ListTablesResponse | null | undefined): SchemaTable[] {
+    if (!payload) return [];
+
+    if (Array.isArray(payload)) {
+        if (payload.length && typeof payload[0] === 'string') {
+            return (payload as string[]).map((name) => ({ name }));
+        }
+        return payload as SchemaTable[];
+    }
+
+    const anyPayload: any = payload;
+    if (Array.isArray(anyPayload?.results)) return anyPayload.results;
+    if (Array.isArray(anyPayload?.tables)) return anyPayload.tables;
+
+    return [];
+}
+
+export async function getSchemaTables(signal?: AbortSignal): Promise<SchemaTable[]> {
+    const data = await omrsGet<ListTablesResponse>('/reportbuilder/schema', signal);
+    return normalizeTables(data);
+}

package/src/resources/theme/mamba-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 getMambaTableMeta(
+    table: string,
+    signal?: AbortSignal
+): Promise<TableColumn[]> {
+  const data = await omrsGet<RawMetaResponse>(
+      `/mambatablecolumn?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;

package/src/routes/report-builder.routes.tsx

@@ -0,0 +1,66 @@
+import React from 'react';
+import { Routes, Route, Navigate } from 'react-router-dom';
+
+import ReportBuilderShell from '../components/app-shell/report-builder-shell.component';
+import ReportBuilderLandingPage from '../components/landing/report-builder-landing-page.component';
+
+import ReportDashboardPage from '../components/report/report-dashboard.page.component';
+import ReportEditorPage from '../components/report/report-editor.page.component';
+
+import IndicatorsPage from '../components/indicators/indicators-page.component';
+import SectionsPage from '../components/report-sections/report-sections-page.component';
+import RunReportsPage from '../components/run-reports/run-reports-page.component';
+import DataThemesPage from '../components/data-themes/data-themes-page.component';
+
+import AdminPage from '../components/admin/admin-page.component';
+import ReportCategoriesPage from '../components/admin/report-categories-page.component';
+import AgeCategoriesPage from '../components/admin/age-categories-page.component';
+import AgeGroupsPage from '../components/admin/age-groups-page.component';
+import ReportLibraryPage from '../components/admin/report-library-page.component';
+import ETLSourcesPage from '../components/admin/etl-sources-page.component';
+
+const ReportBuilderRoutes: React.FC = () => {
+    return (
+        <Routes>
+            <Route element={<ReportBuilderShell />}>
+                {/* Home / landing */}
+                <Route path="/" element={<ReportBuilderLandingPage />} />
+
+                {/* Reports */}
+                <Route path="/reports" element={<ReportDashboardPage />} />
+
+                {/* Create / edit report */}
+                <Route path="/new" element={<ReportEditorPage />} />
+                <Route path="/edit/:reportId" element={<ReportEditorPage />} />
+
+                {/* Indicators / sections */}
+                <Route path="/indicators" element={<IndicatorsPage />} />
+                <Route path="/sections" element={<SectionsPage />} />
+
+                {/* Run */}
+                <Route path="/run" element={<RunReportsPage />} />
+
+
+                {/* Admin */}
+                <Route path="/admin" element={<AdminPage />} />
+                <Route path="/admin/report-categories" element={<ReportCategoriesPage />} />
+                <Route path="/admin/age-categories" element={<AgeCategoriesPage />} />
+                <Route path="/admin/age-groups" element={<AgeGroupsPage />} />
+                <Route path="/admin/report-library" element={<ReportLibraryPage />} />
+                <Route path="/admin/etl-sources" element={<ETLSourcesPage />} />
+
+                {/* Data themes now accessed under Admin */}
+                <Route path="/admin/themes" element={<DataThemesPage />} />
+
+                {/* Optional backward compatibility */}
+                <Route path="/themes" element={<Navigate to="/admin/themes" replace />} />
+
+
+                {/* Fallback */}
+                <Route path="*" element={<Navigate to="/" replace />} />
+            </Route>
+        </Routes>
+    );
+};
+
+export default ReportBuilderRoutes;

package/src/routes/report-builder.scss

@@ -0,0 +1,56 @@
+.page {
+  padding: 1rem;
+  height: 100vh;
+  display: flex;
+  flex-direction: column;
+}
+
+.content {
+  margin-top: 1rem;
+}
+
+.designWorkspace {
+  padding-top: 1rem;
+}
+
+.workspaceTitle {
+  margin: 0 0 0.25rem 0;
+  font-weight: 600;
+}
+
+.workspaceHint {
+  margin: 0 0 1rem 0;
+  opacity: 0.75;
+}
+
+.designGrid {
+  display: grid;
+  grid-template-columns: 2fr 3fr;
+  gap: 1rem;
+}
+
+.designLeft,
+.designRight {
+  display: flex;
+  flex-direction: column;
+  gap: 1rem;
+  min-width: 0;
+}
+
+.panel {
+  background: var(--cds-layer-01, #fff);
+  border: 1px solid var(--cds-border-subtle, #e0e0e0);
+  border-radius: 0.5rem;
+  padding: 1rem;
+}
+
+.panelTitle {
+  margin: 0 0 0.25rem 0;
+  font-weight: 600;
+}
+
+.panelHint {
+  margin: 0;
+  opacity: 0.75;
+  font-size: 0.875rem;
+}

package/src/routes.json

@@ -0,0 +1,21 @@
+{
+  "$schema": "https://json.openmrs.org/routes.schema.json",
+  "pages": [
+    {
+      "component": "root",
+      "route": "report-builder",
+      "online": true,
+      "offline": false,
+      "order": 1
+    }
+  ],
+  "extensions": [
+    {
+      "name": "system-administration-report-builder-card-link",
+      "slot": "system-admin-page-card-link-slot",
+      "component": "reportBuilderAdminLink",
+      "online": true,
+      "offline": false
+    }
+  ]
+}

package/src/sample-template.ts

@@ -0,0 +1,121 @@
+import { nanoid } from 'nanoid';
+
+export type DisaggregationDimension = {
+  name: string;
+  items: Array<{ id: string; label: string }>;
+};
+
+export type IndicatorNode = {
+  id: string;
+  label: string;
+  code?: string;
+  type?: 'group' | 'indicator';
+  children?: IndicatorNode[];
+};
+
+export type MappingGroup = {
+  id: string;
+  title: string;
+  keyPattern?: string;
+  dims?: Record<string, string>;
+  indicatorTree: IndicatorNode[];
+};
+
+export type TemplateModel = {
+  version: number;
+  title: string;
+  dimensions: Record<string, Array<{ id: string; label: string }>>;
+  mapping: {
+    arrayName: string;
+    defaultValue: number;
+    groups: MappingGroup[];
+  };
+};
+
+export function buildDefaultTemplate(): TemplateModel {
+  const age = [
+    { id: '0-28d', label: '0-28d' },
+    { id: '29d-4y', label: '29d-4y' },
+    { id: '5-9y', label: '5-9y' },
+    { id: '10-19y', label: '10-19y' },
+    { id: '20yrs+', label: '20yrs+' },
+  ];
+
+  const sex = [
+    { id: 'M', label: 'M' },
+    { id: 'F', label: 'F' },
+  ];
+
+  const makeGroup = (title: string, indicatorTree: IndicatorNode[]): MappingGroup => ({
+    id: nanoid(),
+    title,
+    keyPattern: '{code}_{age}_{sex}',
+    dims: { age: 'age', sex: 'sex' },
+    indicatorTree,
+  });
+
+  return {
+    version: 4,
+    title: '1.0 OPD ATTENDANCES, REFERRALS AND DIAGNOSES (Sample)',
+    dimensions: { age, sex },
+    mapping: {
+      arrayName: 'dataValues',
+      defaultValue: 0,
+      groups: [
+        makeGroup('1.1 OUTPATIENT ATTENDANCE', [
+          { id: nanoid(), label: 'OA01. New attendance', code: 'OA01' },
+          { id: nanoid(), label: 'OA02. Reattendance', code: 'OA02' },
+        ]),
+        makeGroup('1.2 OUTPATIENT REFERRALS', [
+          { id: nanoid(), label: 'OR01. Referrals to unit', code: 'OR01' },
+          { id: nanoid(), label: 'OR02. Referrals from unit', code: 'OR02' },
+        ]),
+        makeGroup('1.3.1 Epidemic-Prone Diseases', [
+          {
+            id: nanoid(),
+            label: 'EP01. Malaria',
+            code: 'EP01',
+            type: 'group',
+            children: [
+              { id: nanoid(), label: 'EP01a. Suspected Malaria (fever)', code: 'EP01a' },
+              { id: nanoid(), label: 'EP01b. Malaria Tested (B/s & RDT )', code: 'EP01b' },
+              { id: nanoid(), label: 'EP01c. Malaria confirmed (B/s & RDT)', code: 'EP01c' },
+              { id: nanoid(), label: 'EP01d. Confirmed Malaria cases treated', code: 'EP01d' },
+              { id: nanoid(), label: 'EP01e. Total malaria cases treated', code: 'EP01e' },
+            ],
+          },
+          { id: nanoid(), label: 'EP02. Acute Flaccid Paralysis', code: 'EP02' },
+          { id: nanoid(), label: 'EP03. Animal Bites (suspected rabies)', code: 'EP03' },
+          { id: nanoid(), label: 'EP04. Cholera', code: 'EP04' },
+          { id: nanoid(), label: 'EP05. Dysentery', code: 'EP05' },
+          { id: nanoid(), label: 'EP06. Guinea Worm', code: 'EP06' },
+          { id: nanoid(), label: 'EP07. Measles', code: 'EP07' },
+          { id: nanoid(), label: 'EP08. Bacterial Meningitis', code: 'EP08' },
+          { id: nanoid(), label: 'EP09. Neonatal tetanus', code: 'EP09' },
+          { id: nanoid(), label: 'EP10. Plague', code: 'EP10' },
+          { id: nanoid(), label: 'EP11. Yellow Fever', code: 'EP11' },
+          { id: nanoid(), label: 'EP12. Other Viral Haemorrhagic Fevers', code: 'EP12' },
+          { id: nanoid(), label: 'EP13. Severe Acute Respiratory Infection (SARI)', code: 'EP13' },
+          {
+            id: nanoid(),
+            label: 'EP14. Adverse Events Following Immunization (AEFI)',
+            code: 'EP14',
+            type: 'group',
+            children: [
+              { id: nanoid(), label: 'Serious', code: 'EP14_Serious' },
+              { id: nanoid(), label: 'Non Serious', code: 'EP14_NonSerious' },
+            ],
+          },
+          { id: nanoid(), label: 'EP15. Typhoid Fever', code: 'EP15' },
+          { id: nanoid(), label: 'EP16. Refampicin resistant TB cases', code: 'EP16' },
+          {
+            id: nanoid(),
+            label: 'EP17. Other Emerging infectious Diseases e.g. Influenza like illness (ILI), SARS',
+            code: 'EP17',
+          },
+          { id: nanoid(), label: 'EP18. Covid-19', code: 'EP18' },
+        ]),
+      ],
+    },
+  };
+}

package/src/template-utils.ts

@@ -0,0 +1,110 @@
+import type { IndicatorNode, MappingGroup, TemplateModel } from './sample-template';
+
+export function isGroupNode(n: IndicatorNode): boolean {
+  return Boolean(n.children && n.children.length);
+}
+
+export function collectLeafIndicatorCodes(nodes: IndicatorNode[]): string[] {
+  const out: string[] = [];
+  const walk = (arr: IndicatorNode[]) => {
+    for (const n of arr) {
+      if (n.children && n.children.length) {
+        walk(n.children);
+      } else if (n.code) {
+        out.push(n.code);
+      }
+    }
+  };
+  walk(nodes);
+  return out;
+}
+
+/**
+ * ✅ EXISTING in your repo (keep it)
+ * Converts the in-app model into the JSON template format.
+ */
+export function toJsonTemplate(tpl: TemplateModel) {
+  return {
+    version: tpl.version,
+    title: tpl.title,
+    dimensions: tpl.dimensions,
+    mapping: {
+      arrayName: tpl.mapping.arrayName,
+      defaultValue: tpl.mapping.defaultValue,
+      groups: tpl.mapping.groups.map((g: MappingGroup) => ({
+        id: g.id,
+        title: g.title,
+        keyPattern: g.keyPattern ?? '{code}_{age}_{sex}',
+        dims: g.dims ?? { age: 'age', sex: 'sex' },
+        indicatorTree: g.indicatorTree,
+        indicatorCodes: collectLeafIndicatorCodes(g.indicatorTree),
+      })),
+    },
+  };
+}
+
+/**
+ * ✅ NEW
+ * Convert JSON template back into TemplateModel.
+ * We overlay onto defaultsBase so any missing fields are filled from defaults.
+ */
+export function fromJsonTemplate(json: any, defaultsBase: TemplateModel): TemplateModel {
+  if (!json || typeof json !== 'object') {
+    throw new Error('JSON template must be an object');
+  }
+
+  const model = structuredClone(defaultsBase);
+
+  // Validate & map groups (this matches your toJsonTemplate output)
+  const incomingGroups = json?.mapping?.groups;
+  if (!Array.isArray(incomingGroups)) {
+    throw new Error('Invalid JSON: expected mapping.groups to be an array');
+  }
+
+  // Overlay groups onto existing defaults by id when possible
+  model.mapping.groups = incomingGroups.map((g: any) => {
+    if (!g?.id) throw new Error('Invalid JSON: group missing id');
+
+    return {
+      // keep defaults if present, but overlay JSON
+      id: String(g.id),
+      title: String(g.title ?? 'Group'),
+      keyPattern: g.keyPattern ? String(g.keyPattern) : '{code}_{age}_{sex}',
+      dims: g.dims ?? { age: 'age', sex: 'sex' },
+
+      // ✅ the important part
+      indicatorTree: Array.isArray(g.indicatorTree) ? g.indicatorTree.map(normalizeNode) : [],
+    } as MappingGroup;
+  });
+
+  // Optional overlays (safe)
+  if (typeof json.version === 'string') model.version = json.version;
+  if (typeof json.title === 'string') model.title = json.title;
+  if (json.dimensions && typeof json.dimensions === 'object') model.dimensions = json.dimensions;
+
+  if (json?.mapping?.arrayName) model.mapping.arrayName = String(json.mapping.arrayName);
+  if (json?.mapping?.defaultValue != null) model.mapping.defaultValue = json.mapping.defaultValue;
+
+  return model;
+}
+
+function normalizeNode(n: any): IndicatorNode {
+  if (!n || typeof n !== 'object') {
+    throw new Error('Invalid node: node must be an object');
+  }
+  if (!n.id) {
+    throw new Error('Invalid node: missing id');
+  }
+
+  const node: IndicatorNode = {
+    id: String(n.id),
+    label: String(n.label ?? ''),
+    code: n.code != null ? String(n.code) : '',
+  };
+
+  if (Array.isArray(n.children) && n.children.length) {
+    node.children = n.children.map(normalizeNode);
+  }
+
+  return node;
+}

package/src/types/carbon-react-inert.d.ts

@@ -0,0 +1,13 @@
+// Workaround for TS type mismatch between Carbon SideNavProps and the `inert` prop
+// used by @openmrs/esm-styleguide's LeftNavMenu.
+// This avoids type-check failures during local builds.
+
+import '@carbon/react';
+
+declare module '@carbon/react' {
+  // `inert` is a valid HTML attribute supported by browsers, but may be missing from
+  // the Carbon SideNavProps typing in some versions.
+  interface SideNavProps {
+    inert?: boolean;
+  }
+}

package/src/types/condition-operators.ts

@@ -0,0 +1,49 @@
+// src/report-builder/types/condition-operators.ts
+
+/**
+ * Central source of truth for operators used across:
+ * - Theme definition UI
+ * - Indicator condition saving
+ * - SQL rendering
+ */
+
+/** Operators shown/allowed in Theme editor UI */
+export const THEME_OPERATOR_OPTIONS = ['EQUALS', 'IN', 'NOT_IN', 'LIKE', 'BETWEEN', 'GTE', 'LTE'] as const;
+export type ThemeOperator = (typeof THEME_OPERATOR_OPTIONS)[number];
+
+/** SQL operators after normalization */
+export type NormalizedSqlOperator =
+    | '='
+    | '!='
+    | '>'
+    | '>='
+    | '<'
+    | '<='
+    | 'IN'
+    | 'NOT IN'
+    | 'LIKE'
+    | 'BETWEEN';
+
+export function normalizeOperator(op?: string | null): NormalizedSqlOperator {
+    const raw = String(op ?? '').trim().toUpperCase();
+
+    if (raw === 'EQUALS') return '=';
+    if (raw === 'GTE') return '>=';
+    if (raw === 'LTE') return '<=';
+    if (raw === 'NOT_IN') return 'NOT IN';
+    if (raw === 'IN') return 'IN';
+    if (raw === 'LIKE') return 'LIKE';
+    if (raw === 'BETWEEN') return 'BETWEEN';
+
+    // allow already-normalized SQL ops
+    if (raw === '=' || raw === '!=' || raw === '>' || raw === '>=' || raw === '<' || raw === '<=') {
+        return raw as NormalizedSqlOperator;
+    }
+
+    // safest default
+    return 'IN';
+}
+
+export function isInOperator(op: NormalizedSqlOperator) {
+    return op === 'IN' || op === 'NOT IN';
+}