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

package/src/components/indicators/utils/composite-indicator-sql.utils.ts

@@ -0,0 +1,206 @@
+import type { IndicatorDto } from '../../../resources/indicator/indicators.api';
+
+export type CountSqlSource =
+    | 'indicator.sqlTemplate'
+    | 'configJson.sqlPreview'
+    | 'configJson.sqlTemplate'
+    | 'configJson.base.sqlPreview'
+    | 'configJson.base.sqlTemplate'
+    | 'configJson.authoring.base.sqlPreview'
+    | 'configJson.authoring.base.sqlTemplate'
+    | 'configJson.baseIndicator.sqlPreview'
+    | 'configJson.baseIndicator.sqlTemplate'
+    | 'none'
+    | 'none(parse-error)';
+
+export function idFieldForUnit(unit: 'Patients' | 'Encounters') {
+    return unit === 'Encounters' ? 'encounter_id' : 'patient_id';
+}
+
+/**
+ * Extract patientIdColumn from stored authoring (if present),
+ * otherwise fallback to "patient_id".
+ */
+export function tryGetPatientIdColumnFromConfig(ind: IndicatorDto): string {
+    try {
+        const parsed: any = ind?.configJson ? JSON.parse(ind.configJson) : null;
+
+        const cfg =
+            parsed?.themeConfig ||
+            parsed?.base?.themeConfig ||
+            parsed?.authoring?.base?.themeConfig ||
+            parsed?.baseIndicator?.themeConfig ||
+            null;
+
+        const pid = cfg?.patientIdColumn;
+        return pid ? String(pid) : 'patient_id';
+    } catch {
+        return 'patient_id';
+    }
+}
+
+/**
+ * ✅ Key fix:
+ * Many times the backend returns sqlTemplate empty, but configJson contains sqlPreview.
+ * We support all known config shapes.
+ */
+export function tryGetCountSqlFromIndicator(ind: IndicatorDto): { sql: string; source: CountSqlSource } {
+    const direct = (ind?.sqlTemplate ?? '').trim();
+    if (direct) return { sql: direct, source: 'indicator.sqlTemplate' };
+
+    try {
+        const parsed: any = ind?.configJson ? JSON.parse(ind.configJson) : null;
+
+        // flat
+        const flatPreview = (parsed?.sqlPreview ?? '').trim();
+        if (flatPreview) return { sql: flatPreview, source: 'configJson.sqlPreview' };
+
+        const flatTemplate = (parsed?.sqlTemplate ?? '').trim();
+        if (flatTemplate) return { sql: flatTemplate, source: 'configJson.sqlTemplate' };
+
+        // base
+        const basePreview = (parsed?.base?.sqlPreview ?? '').trim();
+        if (basePreview) return { sql: basePreview, source: 'configJson.base.sqlPreview' };
+
+        const baseTemplate = (parsed?.base?.sqlTemplate ?? '').trim();
+        if (baseTemplate) return { sql: baseTemplate, source: 'configJson.base.sqlTemplate' };
+
+        // authoring.base
+        const authPreview = (parsed?.authoring?.base?.sqlPreview ?? '').trim();
+        if (authPreview) return { sql: authPreview, source: 'configJson.authoring.base.sqlPreview' };
+
+        const authTemplate = (parsed?.authoring?.base?.sqlTemplate ?? '').trim();
+        if (authTemplate) return { sql: authTemplate, source: 'configJson.authoring.base.sqlTemplate' };
+
+        // sometimes wrapped differently
+        const biPreview = (parsed?.baseIndicator?.sqlPreview ?? '').trim();
+        if (biPreview) return { sql: biPreview, source: 'configJson.baseIndicator.sqlPreview' };
+
+        const biTemplate = (parsed?.baseIndicator?.sqlTemplate ?? '').trim();
+        if (biTemplate) return { sql: biTemplate, source: 'configJson.baseIndicator.sqlTemplate' };
+
+        return { sql: '', source: 'none' };
+    } catch {
+        return { sql: '', source: 'none(parse-error)' };
+    }
+}
+
+/**
+ * Convert a base indicator COUNT sqlTemplate into a population query.
+ *
+ * Supports BOTH:
+ *  A) Base-style COUNT SQL:
+ *     SELECT COUNT(*) AS total
+ *     FROM <table> a
+ *     ...
+ *
+ *  B) Composite-style COUNT SQL:
+ *     WITH A AS (...), B AS (...)
+ *     SELECT COUNT(*) AS total
+ *     FROM ( SELECT A.patient_id ... ) X;
+ *
+ * For composite-style, we MUST preserve the WITH ... prefix,
+ * otherwise the resulting query references A/B without defining them.
+ */
+export function countSqlToPopulationSql(sql: string, idColumn: string, unit: 'Patients' | 'Encounters') {
+    const idField = idFieldForUnit(unit);
+
+    const raw = (sql ?? '').trim();
+    if (!raw) return '';
+
+    // normalize trailing semicolons
+    const noSemi = raw.replace(/;+\s*$/, '');
+
+    // ✅ Case 1: Composite COUNT SQL
+    // Preserve any WITH CTE prefix (e.g. WITH A AS (...), B AS (...))
+    // Replace "SELECT COUNT(*) AS total FROM ( <inner select> ) X" with a population select.
+    const countIdx = noSemi.search(/SELECT\s+COUNT\s*\(\s*\*\s*\)\s+AS\s+total/i);
+    const innerMatch = noSemi.match(/FROM\s*\(\s*(SELECT[\s\S]*?)\)\s*X\b/i);
+
+    if (countIdx >= 0 && innerMatch?.[1]) {
+        const prefix = noSemi.slice(0, countIdx).trim(); // keeps WITH A,B if present
+        const inner = innerMatch[1].trim().replace(/;+\s*$/, '');
+
+        return `
+${prefix}
+SELECT DISTINCT pop.${idField} AS ${idField}
+FROM (
+${inner}
+) pop
+`.trim();
+    }
+
+    // ✅ Case 2: Base COUNT SQL (assumes alias "a" exists in query)
+    // Replace the COUNT select with a DISTINCT id select.
+    const replaced = noSemi.replace(
+        /SELECT\s+([\s\S]*?)COUNT\s*\(\s*\*\s*\)\s+AS\s+total\s*/i,
+        `SELECT DISTINCT a.${idColumn} AS ${idField}\n`,
+    );
+
+    // If it didn’t replace, fallback: try simpler replace
+    if (replaced === noSemi) {
+        return noSemi.replace(/COUNT\s*\(\s*\*\s*\)\s+AS\s+total/gi, `DISTINCT a.${idColumn} AS ${idField}`);
+    }
+
+    return replaced;
+}
+
+/**
+ * Build composite COUNT SQL from two population queries.
+ * Population queries MUST return a column named patient_id or encounter_id.
+ */
+export function buildCompositeCountSql(args: {
+    unit: 'Patients' | 'Encounters';
+    operator: 'AND' | 'OR' | 'A_AND_NOT_B';
+    populationSqlA: string;
+    populationSqlB: string;
+}) {
+    const idField = idFieldForUnit(args.unit);
+
+    const A = args.populationSqlA.trim().replace(/;+\s*$/, '');
+    const B = args.populationSqlB.trim().replace(/;+\s*$/, '');
+
+    if (!A || !B) return '';
+
+    if (args.operator === 'AND') {
+        return `
+WITH
+A AS (${A}),
+B AS (${B})
+SELECT COUNT(*) AS total
+FROM (
+  SELECT A.${idField}
+  FROM A
+  INNER JOIN B ON B.${idField} = A.${idField}
+) X;
+`.trim();
+    }
+
+    if (args.operator === 'OR') {
+        return `
+WITH
+A AS (${A}),
+B AS (${B})
+SELECT COUNT(*) AS total
+FROM (
+  SELECT ${idField} FROM A
+  UNION
+  SELECT ${idField} FROM B
+) X;
+`.trim();
+    }
+
+    // A_AND_NOT_B
+    return `
+WITH
+A AS (${A}),
+B AS (${B})
+SELECT COUNT(*) AS total
+FROM (
+  SELECT A.${idField}
+  FROM A
+  LEFT JOIN B ON B.${idField} = A.${idField}
+  WHERE B.${idField} IS NULL
+) X;
+`.trim();
+}

package/src/components/indicators/utils/concept-preload.utils.ts

@@ -0,0 +1,21 @@
+import { omrsGet } from '../../../resources/openmrs-api';
+import type { ConceptSummary } from '../../../resources/concepts/concept-types';
+import type { SelectedConcept } from '../handler/concept-search-multiselect.component';
+
+export async function searchConcepts(q: string, signal?: AbortSignal): Promise<ConceptSummary[]> {
+    const trimmed = q.trim();
+    if (!trimmed) return [];
+    const data = await omrsGet<any>(`/concept?q=${encodeURIComponent(trimmed)}&v=default`, signal);
+    const results = Array.isArray(data?.results) ? data.results : Array.isArray(data) ? data : [];
+    return results as ConceptSummary[];
+}
+
+export function toSelectedConcept(c: any): SelectedConcept {
+    return {
+        id: Number(c.id) || 0,
+        uuid: c.uuid,
+        display: c.display,
+        conceptClass: c.conceptClass?.name,
+        datatype: c.datatype?.name,
+    };
+}

package/src/components/indicators/utils/final-indicator-sql.utils.ts

@@ -0,0 +1,124 @@
+import type { IndicatorDto } from '../../../resources/indicator/indicators.api';
+
+import {
+    countSqlToPopulationSql,
+    tryGetPatientIdColumnFromConfig,
+    tryGetCountSqlFromIndicator,
+} from './composite-indicator-sql.utils';
+
+export type FinalIndicatorAuthoringV1 = {
+    version: 1;
+    baseIndicatorId: string;
+
+    // Backward/forward compatibility
+    ageGroupSetCode?: string;
+    ageCategoryCode?: string;
+
+    genders: Array<'F' | 'M'>;
+    sqlPreview: string;
+};
+
+type BuildFinalSqlArgs = {
+    baseIndicator: IndicatorDto;
+    ageCategoryCode: string;
+    genders: Array<'F' | 'M'>;
+};
+
+/**
+ * Builds a Final Indicator query that ALWAYS returns all age groups (even if value = 0),
+ * and for each selected gender.
+ *
+ * Strategy:
+ *  - base_pop: patient population set from base indicator
+ *  - ag: all age groups for the selected category (active only)
+ *  - genders: the selected genders as rows
+ *  - cnt: computed counts per (age_group_id, gender)
+ *  - final: ag CROSS JOIN genders LEFT JOIN cnt, COALESCE(value,0)
+ */
+export function buildFinalIndicatorSql({ baseIndicator, ageCategoryCode, genders }: BuildFinalSqlArgs): string {
+    const { sql: countSql } = tryGetCountSqlFromIndicator(baseIndicator);
+    const pidCol = tryGetPatientIdColumnFromConfig(baseIndicator);
+
+    const populationSql = countSql ? countSqlToPopulationSql(countSql, pidCol, 'Patients') : '';
+
+    if (!populationSql.trim()) {
+        return `-- Unable to build final indicator SQL: base indicator does not contain usable count SQL.\n-- Ensure the base indicator has a valid sqlTemplate or configJson.sqlPreview.`;
+    }
+
+    // If user unchecks everything, default to both (better UX than returning no rows)
+    const selectedGenders = (genders ?? []).length ? genders : (['F', 'M'] as Array<'F' | 'M'>);
+
+    const gendersCte = buildGenderCte(selectedGenders);
+
+    // NOTE: adjust these table names if your DB uses different names.
+    // If you adopted the new naming, use report_builder_dim_age_category/group.
+    const AGE_CATEGORY_TABLE = 'report_builder_dim_age_category';
+    const AGE_GROUP_TABLE = 'report_builder_dim_age_group';
+
+    return `
+WITH base_pop AS (
+${indent(populationSql.trim(), 2)}
+),
+ag AS (
+  SELECT
+    ag.age_group_id,
+    ag.label,
+    ag.min_age_days,
+    ag.max_age_days,
+    ag.sort_order
+  FROM ${AGE_GROUP_TABLE} ag
+  JOIN ${AGE_CATEGORY_TABLE} ac
+    ON ac.age_category_id = ag.age_category_id
+  WHERE ac.code = '${escapeSqlLiteral(ageCategoryCode)}'
+    AND ag.is_active = 1
+),
+genders AS (
+${indent(gendersCte, 2)}
+),
+cnt AS (
+  SELECT
+    ag.age_group_id AS age_group_id,
+    mdp.gender AS gender,
+    COUNT(DISTINCT base_pop.patient_id) AS value
+  FROM base_pop
+  JOIN mamba_fact_patients_latest_patient_demographics mdp
+    ON mdp.patient_id = base_pop.patient_id
+  JOIN ag
+    ON TIMESTAMPDIFF(DAY, mdp.birthdate, ':endDate')
+       BETWEEN ag.min_age_days AND ag.max_age_days
+  WHERE mdp.birthdate IS NOT NULL
+    AND mdp.gender IS NOT NULL
+    AND mdp.gender IN (${selectedGenders.map((g) => `'${g}'`).join(',')})
+  GROUP BY ag.age_group_id, mdp.gender
+)
+SELECT
+  ag.label AS age_group,
+  g.gender AS gender,
+  COALESCE(cnt.value, 0) AS value
+FROM ag
+CROSS JOIN genders g
+LEFT JOIN cnt
+  ON cnt.age_group_id = ag.age_group_id
+ AND cnt.gender = g.gender
+ORDER BY ag.sort_order, g.gender;
+`.trim();
+}
+
+function buildGenderCte(genders: Array<'F' | 'M'>): string {
+    // Produce rows:
+    // SELECT 'F' AS gender UNION ALL SELECT 'M' AS gender
+    const parts = genders.map((g, i) => (i === 0 ? `SELECT '${g}' AS gender` : `UNION ALL SELECT '${g}' AS gender`));
+    return parts.join('\n');
+}
+
+function indent(s: string, spaces: number) {
+    const pad = ' '.repeat(spaces);
+    return s
+        .split('\n')
+        .map((l) => (l.trim().length ? pad + l : l))
+        .join('\n');
+}
+
+function escapeSqlLiteral(s: string) {
+    return String(s).replace(/'/g, "''");
+}

package/src/components/indicators/utils/indicator-conditions-hydration.utils.ts

@@ -0,0 +1,254 @@
+// src/report-builder/components/indicators/utils/indicator-conditions-hydration.utils.ts
+
+import type { ThemeCondition } from '../types/data-theme-config.types';
+import type { IndicatorCondition } from '../types/indicator-types';
+
+import { getConceptByUuid } from '../../../resources/concepts/concepts.resource';
+import type { ConceptSummary } from '../../../resources/concepts/concept-types';
+
+import { toSelectedConcept, type SelectedConcept } from '../handler/concept-search-multiselect.component';
+import type { ConceptUiMap, QaUiMap } from '../types/condition-ui.types';
+
+export type HydrationOptions = {
+    force?: boolean;
+    dedupe?: boolean;
+    preserveUnknownKeys?: boolean;
+};
+
+export type HydrationResult = {
+    conceptUi: ConceptUiMap;
+    qaUi: QaUiMap;
+    stats: {
+        themeConditionsCount: number;
+        pickedConditionsCount: number;
+        conceptConditionsHydrated: number;
+        qaConditionsHydrated: number;
+        tokensHydrated: number;
+        tokensMissed: number;
+    };
+};
+
+// Stored value shape in pickedConditions for QA handler
+// (support both legacy single-question and current multi-question formats)
+type QAValue = {
+    question?: string | number | null;
+    questions?: Array<string | number>;
+    answers?: Array<string | number>;
+};
+
+function uniq(tokens: string[]) {
+    const out: string[] = [];
+    const seen = new Set<string>();
+    for (const t of tokens) {
+        const k = String(t ?? '').trim();
+        if (!k) continue;
+        if (seen.has(k)) continue;
+        seen.add(k);
+        out.push(k);
+    }
+    return out;
+}
+
+/**
+ * Hydrate ONE token into ConceptSummary (internal).
+ * We now persist UUIDs, so we call direct endpoint by UUID.
+ */
+async function hydrateConceptSummaryToken(token: string, signal?: AbortSignal): Promise<ConceptSummary | null> {
+    const tok = String(token ?? '').trim();
+    if (!tok) return null;
+
+    try {
+        const concept = await getConceptByUuid(tok, signal);
+        if (!concept?.uuid) return null;
+        return concept;
+    } catch {
+        return null;
+    }
+}
+
+/**
+ * Hydrate ONE token into SelectedConcept (UI shape).
+ * ✅ Uses toSelectedConcept so ICD mappings are preserved.
+ */
+async function hydrateConceptToken(token: string, signal?: AbortSignal): Promise<SelectedConcept | null> {
+    const cs = await hydrateConceptSummaryToken(token, signal);
+    return cs ? toSelectedConcept(cs) : null;
+}
+
+/**
+ * Hydrate MANY tokens into SelectedConcept[].
+ * ✅ for-loop; preserves order; returns only valid concepts.
+ */
+async function hydrateConceptTokens(tokens: string[], signal?: AbortSignal, dedupe = true): Promise<SelectedConcept[]> {
+    const clean = dedupe ? uniq(tokens) : tokens.map((t) => String(t ?? '').trim()).filter(Boolean);
+    if (!clean.length) return [];
+
+    const results: SelectedConcept[] = [];
+
+    for (const tok of clean) {
+        if (signal?.aborted) break;
+
+        try {
+            const concept = await hydrateConceptToken(tok, signal);
+            if (concept) results.push(concept);
+        } catch {
+            // ignore individual token failures
+        }
+    }
+
+    return results;
+}
+
+/**
+ * Hydrates UI state for concept-based conditions (edit mode):
+ * - iterate picked first (source of truth)
+ * - match to themeByKey for handler
+ * - ensure defaults for theme conditions not saved
+ */
+export async function hydrateConditionUiState(
+    themeConditions: ThemeCondition[] | undefined,
+    pickedConditions: IndicatorCondition[] | undefined,
+    existingConceptUi: ConceptUiMap | undefined,
+    existingQaUi: QaUiMap | undefined,
+    signal?: AbortSignal,
+    options?: HydrationOptions,
+): Promise<HydrationResult> {
+    const opt: Required<HydrationOptions> = {
+        force: options?.force ?? true,
+        dedupe: options?.dedupe ?? true,
+        preserveUnknownKeys: options?.preserveUnknownKeys ?? true,
+    };
+
+    const themeList = themeConditions ?? [];
+    const pickedList = pickedConditions ?? [];
+
+    const themeByKey = new Map<string, ThemeCondition>();
+    for (const tc of themeList) {
+        if (tc?.key) themeByKey.set(tc.key, tc);
+    }
+
+    const nextConceptUi: ConceptUiMap = { ...(existingConceptUi ?? {}) };
+    const nextQaUi: QaUiMap = { ...(existingQaUi ?? {}) };
+
+    let conceptConditionsHydrated = 0;
+    let qaConditionsHydrated = 0;
+    let tokensHydrated = 0;
+    let tokensMissed = 0;
+
+    const seenKeys = new Set<string>();
+
+    // 1) hydrate from picked conditions (source of truth)
+    for (const pc of pickedList) {
+        if (!pc?.key) continue;
+        seenKeys.add(pc.key);
+
+        const tc = themeByKey.get(pc.key);
+        if (!tc) {
+            if (!opt.preserveUnknownKeys) {
+                delete nextConceptUi[pc.key];
+                delete nextQaUi[pc.key];
+            }
+            continue;
+        }
+
+        // -----------------------------
+        // CONCEPT_SEARCH
+        // -----------------------------
+        if (tc.handler === 'CONCEPT_SEARCH') {
+            const shouldHydrate =
+                opt.force || !Array.isArray(nextConceptUi[tc.key]) || nextConceptUi[tc.key].length === 0;
+
+            if (!shouldHydrate) continue;
+
+            const raw = pc.value;
+
+            if (Array.isArray(raw) && raw.length) {
+                const tokens = raw.map((x) => String(x)).filter(Boolean);
+                const selected = await hydrateConceptTokens(tokens, signal, opt.dedupe);
+
+                tokensHydrated += selected.length;
+                tokensMissed += Math.max(0, tokens.length - selected.length);
+
+                nextConceptUi[tc.key] = selected;
+            } else {
+                nextConceptUi[tc.key] = [];
+            }
+
+            conceptConditionsHydrated += 1;
+            continue;
+        }
+
+        // -----------------------------
+        // QUESTION_ANSWER_CONCEPT_SEARCH
+        // -----------------------------
+        if (tc.handler === 'QUESTION_ANSWER_CONCEPT_SEARCH') {
+            const existing = nextQaUi[tc.key];
+
+            const shouldHydrate =
+                opt.force ||
+                !existing ||
+                ((existing.questions?.length ?? 0) === 0 && (existing.answers?.length ?? 0) === 0 && !existing.error);
+
+            if (!shouldHydrate) continue;
+
+            const raw: any = pc.value;
+
+            const qa: QAValue | null = raw && typeof raw === 'object' ? (raw as QAValue) : null;
+
+            // ✅ support both shapes: { question } OR { questions: [] }
+            const qTokens: string[] = Array.isArray(qa?.questions)
+                ? (qa?.questions ?? []).map((x) => String(x).trim()).filter(Boolean)
+                : qa?.question !== null && qa?.question !== undefined
+                    ? [String(qa.question).trim()].filter(Boolean)
+                    : [];
+
+            const aTokens: string[] = Array.isArray(qa?.answers)
+                ? (qa?.answers ?? []).map((x) => String(x).trim()).filter(Boolean)
+                : [];
+
+            const questions: SelectedConcept[] = qTokens.length
+                ? await hydrateConceptTokens(qTokens, signal, opt.dedupe)
+                : [];
+
+            const answers: SelectedConcept[] = aTokens.length
+                ? await hydrateConceptTokens(aTokens, signal, opt.dedupe)
+                : [];
+
+            tokensHydrated += questions.length + answers.length;
+            tokensMissed += Math.max(0, qTokens.length - questions.length) + Math.max(0, aTokens.length - answers.length);
+
+            nextQaUi[tc.key] = { questions, answers };
+            qaConditionsHydrated += 1;
+            continue;
+        }
+
+        // other handlers ignored
+    }
+
+    // 2) ensure all theme conditions have UI defaults
+    for (const tc of themeList) {
+        if (!tc?.key) continue;
+
+        if (!seenKeys.has(tc.key)) {
+            if (tc.handler === 'CONCEPT_SEARCH') {
+                if (!Array.isArray(nextConceptUi[tc.key])) nextConceptUi[tc.key] = [];
+            }
+            if (tc.handler === 'QUESTION_ANSWER_CONCEPT_SEARCH') {
+                if (!nextQaUi[tc.key]) nextQaUi[tc.key] = { questions: [], answers: [] };
+            }
+        }
+    }
+
+    return {
+        conceptUi: nextConceptUi,
+        qaUi: nextQaUi,
+        stats: {
+            themeConditionsCount: themeList.length,
+            pickedConditionsCount: pickedList.length,
+            conceptConditionsHydrated,
+            qaConditionsHydrated,
+            tokensHydrated,
+            tokensMissed,
+        },
+    };
+}