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

package/src/components/indicators/types/condition-ui.types.ts

@@ -0,0 +1,11 @@
+import type { SelectedConcept } from '../handler/concept-search-multiselect.component';
+
+export type QAUiState = {
+    /** Selected question concepts (multi-select) */
+    questions: SelectedConcept[];
+    answers: SelectedConcept[];
+    error?: string;
+};
+
+export type ConceptUiMap = Record<string, SelectedConcept[]>;
+export type QaUiMap = Record<string, QAUiState>;

package/src/components/indicators/types/custom-indicator.types.ts

@@ -0,0 +1,161 @@
+/**
+ * Custom Indicator Type Definitions
+ *
+ * Custom indicators are complex indicators that don't fit into BASE/COMPOSITE/FINAL categories.
+ * They have their own complex SQL logic with multiple JOINs, subqueries, and business rules.
+ */
+
+/**
+ * Patient identification column types
+ */
+export type PatientIdColumn = 'client_id' | 'patient_id' | 'person_id';
+
+/**
+ * Population query extraction methods
+ */
+export type PopulationExtractionMethod = 'sqlTemplate' | 'configJson' | 'auto' | 'custom';
+
+/**
+ * Re-disaggregation strategies for custom indicators
+ */
+export type RedisaggregationStrategy = 'population-extraction' | 'query-rewriting' | 'custom' | 'none';
+
+/**
+ * Filter preservation rule - defines which filters should be preserved during disaggregation
+ */
+export type FilterPreservationRule = {
+    /** Filter identifier */
+    name: string;
+    /** Human-readable description */
+    description: string;
+    /** Regex pattern to identify the JOIN clause for this filter */
+    joinPattern: string;
+    /** Regex pattern to identify the WHERE clause for this filter */
+    wherePattern: string;
+    /** Whether this filter is required for the indicator to work correctly */
+    required: boolean;
+};
+
+/**
+ * Custom indicator configuration
+ */
+export type CustomIndicatorConfig = {
+    version: 1;
+
+    /**
+     * Patient identification column
+     * Custom indicators define their own patient ID column instead of using theme config
+     */
+    patientIdColumn: PatientIdColumn;
+
+    /**
+     * Population SQL preview
+     * The extracted population SQL used for section disaggregation
+     */
+    sqlPreview?: string;
+
+    /**
+     * Full SQL template
+     * The complete indicator SQL with COUNT, JOINs, and business logic
+     * Included for consistency with BASE/COMPOSITE/FINAL indicators
+     */
+    sqlTemplate?: string;
+
+    /**
+     * Population query extraction configuration
+     */
+    populationQuery: {
+        /** How to extract population SQL from the indicator */
+        extractFrom: PopulationExtractionMethod;
+        /** Path in configJson if extractFrom is 'configJson' */
+        configPath?: string;
+        /** Custom extraction function if extractFrom is 'custom' */
+        customExtractor?: string;
+    };
+
+    /**
+     * Filter preservation rules
+     * Defines which filters should be preserved during section disaggregation
+     */
+    preserveFilters?: FilterPreservationRule[];
+
+    /**
+     * Re-disaggregation support
+     */
+    supportsRedisaggregation: boolean;
+    /** Strategy for re-disaggregation */
+    redisaggregationStrategy: RedisaggregationStrategy;
+
+    /**
+     * Theme independence
+     * Custom indicators don't require theme configuration
+     */
+    themeIndependent: boolean;
+
+    /**
+     * Business logic description
+     * Helps users understand what the indicator does
+     */
+    businessLogic?: string;
+
+    /**
+     * Expected data sources
+     * Lists the tables/views this indicator queries
+     */
+    dataSources?: string[];
+};
+
+/**
+ * Query structure analysis result
+ */
+export type QueryStructureAnalysis = {
+    /** Patient ID column used in the query */
+    patientIdColumn: PatientIdColumn;
+    /** Whether the query contains a population subquery */
+    hasPopulationQuery: boolean;
+    /** Extracted population SQL */
+    populationSql?: string;
+    /** Filters identified in the query */
+    filters: Array<{
+        name: string;
+        type: 'LEFT JOIN' | 'INNER JOIN' | 'WHERE';
+        pattern: string;
+    }>;
+    /** JOIN structure */
+    joinStructure: Array<{
+        type: 'LEFT JOIN' | 'INNER JOIN' | 'CROSS JOIN';
+        table: string;
+        alias: string;
+        condition: string;
+    }>;
+    /** Whether this query can be re-disaggregated */
+    redisaggregatable: boolean;
+    /** Confidence score for the analysis (0-1) */
+    confidence: number;
+};
+
+/**
+ * Custom indicator authoring metadata
+ * Used when creating/editing custom indicators
+ */
+export type CustomIndicatorAuthoring = {
+    version: 1;
+    /** Indicator category */
+    category: string;
+    /** Business purpose */
+    purpose: string;
+    /** Expected output format */
+    outputFormat: 'count' | 'table' | 'list';
+    /** Configuration for UI */
+    uiConfig?: {
+        /** Whether to show advanced options */
+        showAdvanced: boolean;
+        /** Available parameters */
+        parameters?: Array<{
+            name: string;
+            type: 'date' | 'string' | 'number' | 'boolean';
+            required: boolean;
+            defaultValue?: any;
+        }>;
+    };
+};

package/src/components/indicators/types/data-theme-config.types.ts

@@ -0,0 +1,88 @@
+// src/report-builder/types/theme/data-theme.types.ts
+
+export type MainDataDomain =
+    | 'OBSERVATIONS'
+    | 'TEST_ORDERS'
+    | 'MEDICATION_ORDERS'
+    | 'APPOINTMENTS'
+    | 'MEDICATION_DISPENSE'
+    | 'DIAGNOSIS';
+
+export type FieldType = 'string' | 'number' | 'date' | 'datetime' | 'boolean' | 'coded' | 'json';
+
+export type ThemeField = {
+    key: string;
+    label: string;
+    expr: string;
+    type: FieldType;
+};
+
+export type ConditionHandler =
+    | 'CONCEPT_SEARCH'
+    | 'QUESTION_ANSWER_CONCEPT_SEARCH'
+    | 'TEXT'
+    | 'NUMBER'
+    | 'DATE_RANGE'
+    | 'BOOLEAN'
+    | 'LOCATION_PICKER'
+    | 'CODED_LIST';
+
+/**
+ * Theme-side operator tokens (legacy + UI-friendly).
+ * NOTE: SQL generation will normalize these to real SQL operators.
+ */
+export type ConditionOperator = 'EQUALS' | 'IN' | 'NOT_IN' | 'LIKE' | 'BETWEEN' | 'GTE' | 'LTE' | 'IS_NULL' | 'IS_NOT_NULL';
+
+export type ConditionValueType =
+    | 'conceptUuid'
+    | 'conceptId'
+    | 'string'
+    | 'number'
+    | 'date'
+    | 'datetime'
+    | 'boolean';
+
+export type ThemeCondition = {
+    key: string;
+    label: string;
+    handler: ConditionHandler;
+    column: string;
+    operator: ConditionOperator;
+    valueType: ConditionValueType;
+};
+
+export type DataThemeConfig = {
+    sourceTable: string;
+    patientIdColumn: string;
+    dateColumn: string;
+    locationColumn?: string;
+
+    joins?: Array<{ alias: string; joinSql: string }>;
+    defaultFilters?: string[];
+
+    fields: ThemeField[];
+
+    conditions?: ThemeCondition[];
+
+    conditionColumns?: Record<string, string>;
+};
+
+export type DataTheme = {
+    uuid?: string;
+    name: string;
+    description?: string;
+    code: string;
+    domain: MainDataDomain;
+    configJson: string;
+    metaJson?: string;
+    retired?: boolean;
+};
+
+export type DataThemeRow = {
+    uuid: string;
+    name: string;
+    code: string;
+    domain: MainDataDomain;
+    description?: string;
+    retired?: boolean;
+};

package/src/components/indicators/types/indicator-types.ts

@@ -0,0 +1,57 @@
+import type { DataThemeConfig, ThemeCondition } from './data-theme-config.types';
+
+/**
+ * What the indicator builder saves/uses.
+ * Keep it flexible because you already have a backend model.
+ */
+
+export type IndicatorKind = 'BASE' | 'FINAL' | 'CUSTOM';
+
+export type IndicatorConditionValue =
+    | string
+    | number
+    | boolean
+    | Array<string | number>
+    | { start?: string; end?: string }
+    | null;
+
+export type IndicatorCondition = {
+  key: string; // matches ThemeCondition.key
+  operator?: ThemeCondition['operator'];
+  valueType?: ThemeCondition['valueType'];
+
+  /**
+   * Actual chosen value(s).
+   * - concept search returns ids/uuids depending on your handler config
+   */
+  value: IndicatorConditionValue;
+};
+
+export type BaseIndicatorDraft = {
+  uuid?: string;
+  name: string;
+  description?: string;
+  code?: string;
+
+  kind: IndicatorKind;
+
+  /**
+   * The selected data theme
+   */
+  themeUuid: string;
+
+  /**
+   * Optional snapshot of theme config at save time (good for debugging / auditing)
+   */
+  themeConfig?: DataThemeConfig;
+
+  /**
+   * User-picked conditions (values), keys should match theme config conditions
+   */
+  conditions?: IndicatorCondition[];
+
+  /**
+   * Optional SQL preview used by UI
+   */
+  sqlPreview?: string;
+};

package/src/components/indicators/types/sql-builders.ts

@@ -0,0 +1,43 @@
+/*
+import type { DiagnosisBaseConfig } from './indicator-types';
+
+function normalizeCsvToSqlInList(csv: string) {
+  const cleaned = (csv ?? '')
+      .split(',')
+      .map((x) => x.trim())
+      .filter(Boolean)
+      .map((x) => String(Number(x)))
+      .filter((x) => x !== 'NaN');
+
+  return cleaned.length ? cleaned.join(',') : '1';
+}
+
+function diagnosisClause(ids: number[]) {
+  if (!ids || ids.length === 0) {
+    return `-- AND a.diagnosis_coded = <select a concept>`;
+  }
+  if (ids.length === 1) {
+    return `AND a.diagnosis_coded = ${ids[0]}`;
+  }
+  return `AND a.diagnosis_coded IN (${ids.join(',')})`;
+}
+
+export function buildDiagnosisBaseSql(cfg: DiagnosisBaseConfig) {
+  const ranks = normalizeCsvToSqlInList(cfg.dxRanksCsv);
+
+  return `
+SELECT
+  COUNT(*) AS total
+FROM mamba_fact_encounter_diagnosis a
+JOIN mamba_fact_patients_latest_patient_demographics mdp
+  ON mdp.client_id = a.client_id
+WHERE a.date_created >= :startDate
+  AND a.date_created < :endDate
+  ${diagnosisClause(cfg.conceptIds)}
+  AND a.certainty = '${cfg.certainty}'
+  AND a.dx_rank IN (${ranks})
+  ${cfg.onlyNotVoided ? 'AND a.voided = 0' : ''}
+  ${cfg.requireNonNullBirthdate ? 'AND mdp.birthdate IS NOT NULL' : ''}
+  ${cfg.requireNonNullGender ? 'AND mdp.gender IS NOT NULL' : ''}
+;`.trim();
+}*/

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

@@ -0,0 +1,143 @@
+/**
+ * Unit tests for composite-indicator-sql.utils
+ */
+
+import { describe, it, expect } from '@jest/globals';
+import { countSqlToPopulationSql } from './composite-indicator-sql.utils';
+
+describe('countSqlToPopulationSql', () => {
+  describe('Case 0: COUNT DISTINCT SQL', () => {
+    it('should preserve FROM and WHERE clauses when converting COUNT DISTINCT', () => {
+      const input = 'SELECT COUNT(DISTINCT a.client_id) AS total FROM patients a WHERE a.active = 1';
+      const result = countSqlToPopulationSql(input, 'client_id', 'Patients');
+
+      // Should preserve the FROM and WHERE clauses
+      expect(result).toContain('FROM patients a');
+      expect(result).toContain('WHERE a.active = 1');
+      expect(result).toContain('SELECT DISTINCT a.client_id AS client_id');
+    });
+
+    it('should handle unqualified column references', () => {
+      const input = 'SELECT COUNT(DISTINCT client_id) AS total FROM patients a';
+      const result = countSqlToPopulationSql(input, 'client_id', 'Patients');
+
+      // Should add table alias 'a.' to unqualified column
+      expect(result).toContain('SELECT DISTINCT a.client_id AS client_id');
+      expect(result).toContain('FROM patients a');
+    });
+
+    it('should preserve JOIN clauses', () => {
+      const input =
+        'SELECT COUNT(DISTINCT a.client_id) AS total FROM patients a JOIN demographics d ON d.client_id = a.client_id';
+      const result = countSqlToPopulationSql(input, 'client_id', 'Patients');
+
+      expect(result).toContain('FROM patients a');
+      expect(result).toContain('JOIN demographics d');
+      expect(result).toContain('SELECT DISTINCT a.client_id AS client_id');
+    });
+
+    it('should handle multi-line queries', () => {
+      const input = `SELECT COUNT(DISTINCT a.client_id) AS total
+                     FROM patients a
+                     WHERE a.date >= :startDate
+                       AND a.active = 1`;
+      const result = countSqlToPopulationSql(input, 'client_id', 'Patients');
+
+      expect(result).toContain('FROM patients a');
+      expect(result).toContain('WHERE a.date >= :startDate');
+      expect(result).toContain('AND a.active = 1');
+    });
+  });
+
+  describe('Case 1: Composite COUNT SQL with WITH clauses', () => {
+    it('should preserve WITH CTEs and extract inner query', () => {
+      const input = `WITH A AS (SELECT client_id FROM table_a WHERE x = 1),
+                          B AS (SELECT client_id FROM table_b WHERE y = 2)
+                     SELECT COUNT(*) AS total
+                     FROM (SELECT A.client_id FROM A) X`;
+      const result = countSqlToPopulationSql(input, 'client_id', 'Patients');
+
+      expect(result).toContain('WITH');
+      expect(result).toContain('A AS (');
+      expect(result).toContain('B AS (');
+      expect(result).toContain('SELECT DISTINCT pop.client_id');
+      expect(result).toContain('FROM (');
+    });
+  });
+
+  describe('Case 2: Base COUNT SQL', () => {
+    it('should convert COUNT(*) to DISTINCT select', () => {
+      const input = 'SELECT COUNT(*) AS total FROM patients a WHERE a.active = 1';
+      const result = countSqlToPopulationSql(input, 'client_id', 'Patients');
+
+      expect(result).toContain('SELECT DISTINCT a.client_id AS client_id');
+      expect(result).toContain('FROM patients a');
+      expect(result).toContain('WHERE a.active = 1');
+    });
+  });
+
+  describe('Edge cases', () => {
+    it('should handle empty input', () => {
+      const result = countSqlToPopulationSql('', 'client_id', 'Patients');
+      expect(result).toBe('');
+    });
+
+    it('should handle input with trailing semicolon', () => {
+      const input = 'SELECT COUNT(DISTINCT a.client_id) AS total FROM patients a;';
+      const result = countSqlToPopulationSql(input, 'client_id', 'Patients');
+
+      expect(result).not.toContain(';');
+      expect(result).toContain('FROM patients a');
+    });
+
+    it('should use patient_id for Encounters unit', () => {
+      const input = 'SELECT COUNT(DISTINCT a.encounter_id) AS total FROM encounters a';
+      const result = countSqlToPopulationSql(input, 'encounter_id', 'Encounters');
+
+      expect(result).toContain('SELECT DISTINCT a.encounter_id AS encounter_id');
+    });
+  });
+
+  describe('Improved: COUNT DISTINCT with different table aliases', () => {
+    it('should handle table alias "p" instead of "a"', () => {
+      const input = 'SELECT COUNT(DISTINCT p.patient_id) AS cnt FROM patients p WHERE active = 1';
+      const result = countSqlToPopulationSql(input, 'patient_id', 'Patients');
+
+      expect(result).toContain('SELECT DISTINCT p.patient_id AS patient_id');
+      expect(result).toContain('FROM patients p');
+      expect(result).toContain('WHERE active = 1');
+    });
+
+    it('should handle unqualified column with alias "t"', () => {
+      const input = 'SELECT COUNT(DISTINCT client_id) AS count FROM my_table t';
+      const result = countSqlToPopulationSql(input, 'client_id', 'Patients');
+
+      expect(result).toContain('SELECT DISTINCT t.client_id AS client_id');
+      expect(result).toContain('FROM my_table t');
+    });
+
+    it('should handle AS keyword in FROM clause', () => {
+      const input = 'SELECT COUNT(DISTINCT client_id) AS total FROM patients AS p';
+      const result = countSqlToPopulationSql(input, 'client_id', 'Patients');
+
+      expect(result).toContain('SELECT DISTINCT p.client_id AS client_id');
+      expect(result).toContain('FROM patients AS p');
+    });
+
+    it('should handle alias "base" for composite CTEs', () => {
+      const input = 'SELECT COUNT(DISTINCT base.client_id) AS total FROM population base WHERE base.date >= :startDate';
+      const result = countSqlToPopulationSql(input, 'client_id', 'Patients');
+
+      expect(result).toContain('SELECT DISTINCT base.client_id AS client_id');
+      expect(result).toContain('FROM population base');
+    });
+
+    it('should handle COUNT(*) with different table alias', () => {
+      const input = 'SELECT COUNT(*) AS total FROM encounters e WHERE e.status = "completed"';
+      const result = countSqlToPopulationSql(input, 'encounter_id', 'Encounters');
+
+      expect(result).toContain('SELECT DISTINCT e.encounter_id AS encounter_id');
+      expect(result).toContain('FROM encounters e');
+    });
+  });
+});