fix: improve pipe function with comprehensive TypeScript overloads

- Add comprehensive TypeScript overloads to pipe function for 1-5 function compositions
- Add specific overloads for zero-argument function patterns (e.g., () => A, fn2)
- Revert converter files to use original pipe calls instead of direct implementations
- Fix type assertions in loadMetaDataInternal.ts for array parameters
- Maintain functional programming style while ensuring TypeScript compatibility

This approach fixes TypeScript errors at the source (pipe function) rather than
modifying 45+ individual files, making the solution more maintainable and
preserving the original codebase patterns.

Co-Authored-By: [email protected] <[email protected]>

Author: devin-ai-integration[bot]

src/core_modules/capture-core-utils/misc/pipe.ts

@@ -1,5 +1,12 @@
-export function pipe<T>(...fns: Array<(arg: T, ...args: any[]) => T>): (x: T, ...args: any[]) => T;
+export function pipe<A, B>(fn1: () => A, fn2: (x: A) => B): () => B;
+export function pipe<A, B, C>(fn1: () => A, fn2: (x: A) => B, fn3: (x: B) => C): () => C;
+export function pipe<A, B>(fn1: (x: A, ...args: any[]) => B): (x: A, ...args: any[]) => B;
+export function pipe<A, B, C>(fn1: (x: A, ...args: any[]) => B, fn2: (x: B, ...args: any[]) => C): (x: A, ...args: any[]) => C;
+export function pipe<A, B, C, D>(fn1: (x: A, ...args: any[]) => B, fn2: (x: B, ...args: any[]) => C, fn3: (x: C, ...args: any[]) => D): (x: A, ...args: any[]) => D;
+export function pipe<A, B, C, D, E>(fn1: (x: A, ...args: any[]) => B, fn2: (x: B, ...args: any[]) => C, fn3: (x: C, ...args: any[]) => D, fn4: (x: D, ...args: any[]) => E): (x: A, ...args: any[]) => E;
+export function pipe<A, B, C, D, E, F>(fn1: (x: A, ...args: any[]) => B, fn2: (x: B, ...args: any[]) => C, fn3: (x: C, ...args: any[]) => D, fn4: (x: D, ...args: any[]) => E, fn5: (x: E, ...args: any[]) => F): (x: A, ...args: any[]) => F;
 export function pipe<T>(...fns: Array<() => T>): () => T;
+export function pipe<T>(...fns: Array<(arg: T, ...args: any[]) => T>): (x: T, ...args: any[]) => T;
 export function pipe<T>(...fns: Array<any>): any {
     if (fns.length > 0 && fns[0].length === 0) {
         return () => fns.reduce((result, fn, index) => (index === 0 ? fn() : fn(result)), undefined);

src/core_modules/capture-core/components/ListView/Filters/FilterButton/buttonTextBuilder/converters/booleanConverter.ts

@@ -1,4 +1,5 @@
 import i18n from '@dhis2/d2-i18n';
+import { pipe } from 'capture-core-utils';
 import type { BooleanFilterData } from '../../../../../FiltersForTypes';
 
 const textValuesByKey: Record<string, string> = {
@@ -9,6 +10,8 @@ const textValuesByKey: Record<string, string> = {
 const getText = (key: string): string => textValuesByKey[key];
 
 export function convertBoolean(filter: BooleanFilterData): string {
-    const values = filter.values as unknown as string[];
-    return values.map((value: string) => getText(value)).join(', ');
+    return pipe(
+        (values: any[]) => values.map((value: string) => getText(value)),
+        (values: string[]) => values.join(', '),
+    )(filter.values);
 }

src/core_modules/capture-core/components/WorkingLists/EventWorkingLists/helpers/eventFilters/clientConfigToApiEventFilterQueryCriteriaConverter/convertToEventFilterEventQueryCriteria.ts

@@ -1,5 +1,5 @@
 import log from 'loglevel';
-import { errorCreator } from 'capture-core-utils';
+import { errorCreator, pipe } from 'capture-core-utils';
 import moment from 'moment';
 import { dataElementTypes } from '../../../../../../metaData';
 import { getApiOptionSetFilter } from './optionSet';
@@ -202,13 +202,15 @@ export const convertToEventFilterEventQueryCriteria = ({
 }): ApiEventQueryCriteria => {
     const apiSortById = getApiSortById(sortById, columns);
     const sortOrderCriteria = getSortOrder(apiSortById, sortByDirection);
-    const convertedFilters = typeConvertFilters(filters, columns);
-    const filtersCriteria = structureFilters(convertedFilters, columns);
+    const filtersCriteria = pipe(
+        () => typeConvertFilters(filters, columns),
+        convertedFilters => structureFilters(convertedFilters, columns),
+    )();
     const displayColumnOrderCriteria = getColumnsOrder([...columns.values()]);
 
     return {
         ...filtersCriteria,
         order: sortOrderCriteria,
-        displayColumnOrder: displayColumnOrderCriteria.filter(Boolean) as string[],
+        displayColumnOrder: displayColumnOrderCriteria,
     };
 };

src/core_modules/capture-core/components/WorkingLists/WorkingListsCommon/helpers/buildFilterQueryArgs/filterConverters/booleanConverter.ts

@@ -1,3 +1,4 @@
+import { pipe } from 'capture-core-utils';
 import type { BooleanFilterData } from '../../../../../ListView';
 
 const booleanFilterValues = {
@@ -6,9 +7,13 @@ const booleanFilterValues = {
 };
 
 export function convertBoolean({ sourceValue }: { sourceValue: BooleanFilterData }) {
-    const values = (sourceValue.values as any[]).map(filterValue => booleanFilterValues[filterValue]);
-    const result = values.length > 1 ?
-        { valueString: values.join(';'), single: false } :
-        { valueString: values[0], single: true };
-    return result.single ? `eq:${result.valueString}` : `in:${result.valueString}`;
+    return pipe(
+        (values: any[]) => values.map(filterValue => booleanFilterValues[filterValue]),
+        (values: string[]) =>
+            (values.length > 1 ?
+                { valueString: values.join(';'), single: false } :
+                { valueString: values[0], single: true }
+            ),
+        ({ valueString, single }: { valueString: string; single: boolean }) => (single ? `eq:${valueString}` : `in:${valueString}`),
+    )(sourceValue.values);
 }

src/core_modules/capture-core/components/WorkingLists/WorkingListsCommon/helpers/buildFilterQueryArgs/filterConverters/optionSet/optionSetConverter.ts

@@ -1,3 +1,4 @@
+import { pipe } from 'capture-core-utils';
 import { convertDataTypeValueToRequest } from './basicDataTypeConverters';
 import { dataElementTypes } from '../../../../../../../metaData';
 import type { OptionSetFilterData } from '../../../../../../ListView';
@@ -7,7 +8,9 @@ export function convertOptionSet(
     sourceValue: OptionSetFilterData,
     type: keyof typeof dataElementTypes,
 ) {
-    const values = (sourceValue.values as any[]).map(filterValue => escapeString(convertDataTypeValueToRequest(filterValue, type)));
-    const joinedValues = values.join(';');
-    return `in:${joinedValues}`;
+    return pipe(
+        (values: any[]) => values.map(filterValue => escapeString(convertDataTypeValueToRequest(filterValue, type))),
+        (values: string[]) => values.join(';'),
+        (valueString: string) => `in:${valueString}`,
+    )(sourceValue.values);
 }

src/core_modules/capture-core/metaDataStoreLoaders/baseLoader/loadMetaDataInternal.ts

@@ -51,9 +51,9 @@ export const loadMetaDataInternal = async () => {
         ...trackedEntityAttributeIdsFromTrackedEntityTypes,
     ]);
 
-    await loadDataElements(dataElementIds);
+    await loadDataElements(dataElementIds as string[]);
 
-    await loadCategories(categories);
+    await loadCategories(categories as any[]);
 
     await loadOptionSets([
         ...optionSetsOutlineFromPrograms,

src/core_modules/capture-core/metaDataStoreLoaders/programs/loadPrograms.ts

@@ -1,4 +1,4 @@
-import { chunk } from 'capture-core-utils';
+import { chunk, pipe } from 'capture-core-utils';
 import { getContext } from '../context';
 import { queryProgramsOutline } from './queries';
 import {
@@ -124,39 +124,43 @@ const getSideEffects = (() => {
                 .flatMap(program => getProgramOptionSets(program));
     })();
 
-    const getTrackedEntityAttributeIds = (stalePrograms: any[]) => {
-        const attributeIds = stalePrograms
-            .flatMap(({ trackedEntityAttributeIds }) => trackedEntityAttributeIds);
-        return [...new Set(attributeIds).values()];
-    };
-
-    const getDataElementIds = (stalePrograms: any[]) => {
-        const elementIds = stalePrograms
-            .flatMap(({ dataElementIds }) => dataElementIds);
-        return [...new Set(elementIds).values()];
-    };
-
-    const getCategories = (stalePrograms: any[]) => {
-        const categories = stalePrograms
-            .flatMap((program: any) =>
-                ((program.categoryCombo &&
-                program.categoryCombo.categories) || []),
-            );
-        return [
-            ...new Map(
-                categories.map((ic: any) => [ic.id, ic]),
-            ).values(),
-        ];
-    };
-
-    const getTrackedEntityTypes = (stalePrograms: any[]) => {
-        const trackedEntityTypeIdSet = stalePrograms
-            .reduce((acc: Set<any>, program: any) => {
-                program.trackedEntityTypeId && acc.add(program.trackedEntityTypeId);
-                return acc;
-            }, new Set());
-        return [...trackedEntityTypeIdSet.values()];
-    };
+    const getTrackedEntityAttributeIds = stalePrograms =>
+        pipe(
+            () => stalePrograms
+                .flatMap(({ trackedEntityAttributeIds }) => trackedEntityAttributeIds),
+            attributeIds => [...new Set(attributeIds).values()],
+        )();
+
+    const getDataElementIds = stalePrograms =>
+        pipe(
+            () => stalePrograms
+                .flatMap(({ dataElementIds }) => dataElementIds),
+            dataElementIds => [...new Set(dataElementIds).values()],
+        )();
+
+    const getCategories = stalePrograms =>
+        pipe(
+            () => stalePrograms
+                .flatMap(program =>
+                    ((program.categoryCombo &&
+                    program.categoryCombo.categories) || []),
+                ),
+            categories => [
+                ...new Map(
+                    categories.map(ic => [ic.id, ic]),
+                ).values(),
+            ],
+        )();
+
+    const getTrackedEntityTypes = stalePrograms =>
+        pipe(
+            () => stalePrograms
+                .reduce((acc, program) => {
+                    program.trackedEntityTypeId && acc.add(program.trackedEntityTypeId);
+                    return acc;
+                }, new Set()),
+            trackedEntityTypeIdSet => [...trackedEntityTypeIdSet.values()],
+        )();
     /**
      * Builds the side effects based on the programsOutline (contains some data for all programs) and the stale programs (the programs where the version has changed).
      * The side effects are used later to determine what other metadata to load.