Program indicator sync succeeds but returns no data

i18n/en.pot

@@ -5,8 +5,8 @@ msgstr ""
 "Content-Type: text/plain; charset=utf-8\n"
 "Content-Transfer-Encoding: 8bit\n"
 "Plural-Forms: nplurals=2; plural=(n != 1)\n"
-"POT-Creation-Date: 2025-11-11T12:44:20.444Z\n"
-"PO-Revision-Date: 2025-11-11T12:44:20.444Z\n"
+"POT-Creation-Date: 2026-02-18T08:03:55.681Z\n"
+"PO-Revision-Date: 2026-02-18T08:03:55.681Z\n"
 
 msgid ""
 "THIS NEW RELEASE INCLUDES SHARING SETTINGS PER INSTANCES. FOR THIS VERSION "

src/domain/aggregated/builders/AggregatedPayloadBuilder.ts

@@ -14,18 +14,14 @@ import {
 } from "../../metadata/entities/MetadataEntities";
 import { DataStoreMetadata } from "../../data-store/DataStoreMetadata";
 import _ from "lodash";
-import { DataValue } from "../entities/DataValue";
 import { AggregatedMetadatafields } from "../usecases/AggregatedSyncUseCase";
 import { getMinimumParents } from "../utils";
-
-type AggregatedPayload = {
-    dataValues: DataValue[];
-};
+import { AggregatedPackage } from "../entities/AggregatedPackage";
 
 export class AggregatedPayloadBuilder {
     constructor(private repositoryFactory: DynamicRepositoryFactory, private localInstance: Instance) {}
 
-    public async build(syncBuilder: SynchronizationBuilder, remoteInstance?: Instance): Promise<AggregatedPayload> {
+    public async build(syncBuilder: SynchronizationBuilder, remoteInstance?: Instance): Promise<AggregatedPackage> {
         const { dataParams: { enableAggregation = false } = {} } = syncBuilder;
 
         if (enableAggregation) {

src/domain/events/builders/EventsPayloadBuilder.ts

@@ -8,17 +8,11 @@ import { generateUid } from "../../common/entities/uid";
 import { DataStoreMetadata } from "../../data-store/DataStoreMetadata";
 import _ from "lodash";
 import { ProgramEvent } from "../entities/ProgramEvent";
-import { DataValue } from "../../aggregated/entities/DataValue";
 import { TrackedEntityInstance } from "../../tracked-entity-instances/entities/TrackedEntityInstance";
 import { eventsFields } from "../usecases/EventsSyncUseCase";
 import { Ref } from "../../common/entities/Ref";
 import { TEIRepository } from "../../tracked-entity-instances/repositories/TEIRepository";
-
-export type EventsPayload = {
-    events: ProgramEvent[];
-    dataValues: DataValue[];
-    trackedEntityInstances: TrackedEntityInstance[];
-};
+import { EventsPayload } from "../entities/EventsPayload";
 
 export class EventsPayloadBuilder {
     constructor(private repositoryFactory: DynamicRepositoryFactory, private localInstance: Instance) {}
@@ -94,7 +88,7 @@ export class EventsPayloadBuilder {
 
         const dataValues = _.reject(candidateDataValues, ({ dataElement }) => excludedIds.includes(dataElement));
 
-        return { events, dataValues, trackedEntityInstances };
+        return { events, dataValues, trackedEntities: trackedEntityInstances };
     }
 
     private async buildTrackedEntityInstances(

src/domain/events/entities/EventsPayload.ts

@@ -0,0 +1,9 @@
+import { DataValue } from "../../aggregated/entities/DataValue";
+import { TrackedEntityInstance } from "../../tracked-entity-instances/entities/TrackedEntityInstance";
+import { ProgramEvent } from "./ProgramEvent";
+
+export type EventsPayload = {
+    events: ProgramEvent[];
+    dataValues: DataValue[];
+    trackedEntities: TrackedEntityInstance[];
+};

src/domain/events/repositories/EventsRepository.ts

@@ -1,5 +1,6 @@
 import { DataImportParams, DataSynchronizationParams } from "../../aggregated/entities/DataSynchronizationParams";
 import { SynchronizationResult } from "../../reports/entities/SynchronizationResult";
+import { EventsPackage } from "../entities/EventsPackage";
 import { ProgramEvent } from "../entities/ProgramEvent";
 
 export interface EventsRepository {
@@ -9,7 +10,7 @@ export interface EventsRepository {
         defaults?: string[]
     ): Promise<ProgramEvent[]>;
 
-    save(data: object, additionalParams: DataImportParams | undefined): Promise<SynchronizationResult>;
+    save(data: EventsPackage, additionalParams: DataImportParams | undefined): Promise<SynchronizationResult>;
 
     getEventFile(eventId: string, dataElement: string, fileResourceId: string): Promise<File>;
 }

src/domain/events/usecases/EventsSyncUseCase.ts

@@ -52,7 +52,7 @@ export class EventsSyncUseCase extends GenericSyncUseCase {
 
     public async postPayload(instance: Instance): Promise<SynchronizationResult[]> {
         const payload = await this.buildPayload();
-        const { events, dataValues, trackedEntityInstances } = payload;
+        const { events, dataValues, trackedEntities: trackedEntityInstances } = payload;
         const { dataParams = {} } = this.builder;
 
         const wasAnyTeiSelectedToSync =

src/domain/synchronization/entities/SynchronizationPayload.ts

@@ -1,6 +1,7 @@
 import { AggregatedPackage } from "../../aggregated/entities/AggregatedPackage";
 import { EventsPackage } from "../../events/entities/EventsPackage";
+import { EventsPayload } from "../../events/entities/EventsPayload";
 import { MetadataPackage } from "../../metadata/entities/MetadataEntities";
 import { TEIsPackage } from "../../tracked-entity-instances/entities/TEIsPackage";
 
-export type SynchronizationPayload = MetadataPackage | AggregatedPackage | EventsPackage | TEIsPackage;
+export type SynchronizationPayload = MetadataPackage | AggregatedPackage | EventsPackage | TEIsPackage | EventsPayload;

src/domain/synchronization/usecases/DownloadPayloadFromSyncRuleUseCase.ts

@@ -4,15 +4,12 @@ import { metadataTransformations } from "../../../data/transformations/PackageTr
 import i18n from "../../../utils/i18n";
 import { CompositionRoot } from "../../../presentation/CompositionRoot";
 import { promiseMap } from "../../../utils/common";
-import { AggregatedPackage } from "../../aggregated/entities/AggregatedPackage";
 import { AggregatedSyncUseCase } from "../../aggregated/usecases/AggregatedSyncUseCase";
 import { Either } from "../../common/entities/Either";
 import { UseCase } from "../../common/entities/UseCase";
 import { DynamicRepositoryFactory } from "../../common/factories/DynamicRepositoryFactory";
-import { EventsPackage } from "../../events/entities/EventsPackage";
 import { Instance } from "../../instance/entities/Instance";
 import { SynchronizationRule } from "../../rules/entities/SynchronizationRule";
-import { TEIsPackage } from "../../tracked-entity-instances/entities/TEIsPackage";
 import { createTEIsPayloadMapper } from "../../tracked-entity-instances/mapper/TEIsPayloadMapperFactory";
 import { SynchronizationPayload } from "../entities/SynchronizationPayload";
 import { SynchronizationResultType, SynchronizationType } from "../entities/SynchronizationType";
@@ -23,6 +20,7 @@ import { DownloadRepository } from "../../storage/repositories/DownloadRepositor
 import { TransformationRepository } from "../../transformations/repositories/TransformationRepository";
 import { EventsPayloadBuilder } from "../../events/builders/EventsPayloadBuilder";
 import { AggregatedPayloadBuilder } from "../../aggregated/builders/AggregatedPayloadBuilder";
+import { EventsPayload } from "../../events/entities/EventsPayload";
 
 type DownloadErrors = string[];
 
@@ -57,18 +55,20 @@ export class DownloadPayloadFromSyncRuleUseCase implements UseCase {
 
         const sync: GenericSyncUseCase = this.compositionRoot.sync[rule.type](rule.toBuilder());
 
-        const payload: SynchronizationPayload = await this.buildPayload(rule.type, rule);
-
         const date = moment().format("YYYYMMDDHHmm");
 
         const mappedData =
             rule.type === "events"
-                ? await this.mapEventsSyncRulePayloadToDownloadItems(rule, sync, payload)
+                ? await this.mapEventsSyncRulePayloadToDownloadItems(
+                      rule,
+                      sync,
+                      await this.eventsPayloadBuilder.build(rule.builder)
+                  )
                 : await this.mapToDownloadItems(
                       rule,
                       rule.type,
                       instance => Promise.resolve(new GenericPackageMapper(instance, sync)),
-                      payload
+                      await this.buildPayload(rule.type, rule)
                   );
 
         const errors = mappedData.filter(data => typeof data === "string") as string[];
@@ -143,9 +143,9 @@ export class DownloadPayloadFromSyncRuleUseCase implements UseCase {
     private async mapEventsSyncRulePayloadToDownloadItems(
         rule: SynchronizationRule,
         sync: GenericSyncUseCase,
-        payload: SynchronizationPayload
+        payload: EventsPayload
     ) {
-        const { events } = payload as EventsPackage;
+        const { events } = payload;
 
         const downloadItemsByEvents =
             events.length > 0
@@ -157,7 +157,7 @@ export class DownloadPayloadFromSyncRuleUseCase implements UseCase {
                   )
                 : [];
 
-        const { trackedEntities } = payload as TEIsPackage;
+        const { trackedEntities } = payload;
 
         const downloadItemsByTEIS =
             trackedEntities.length > 0
@@ -177,7 +177,7 @@ export class DownloadPayloadFromSyncRuleUseCase implements UseCase {
                   )
                 : [];
 
-        const { dataValues } = payload as AggregatedPackage;
+        const { dataValues } = payload;
 
         //TODO: we should create AggregatedMapper to don't use this use case here
         const aggregatedSync = new AggregatedSyncUseCase(

src/presentation/react/core/components/sync-wizard/common/SummaryStep.tsx

@@ -103,6 +103,7 @@ export const SummaryStep = ({ syncRule, onCancel }: SyncWizardStepProps) => {
                     i18n.t("You do not have the authority to one or multiple target instances of the sync rule")
                 );
             } else {
+                console.error(error);
                 snackbar.error(i18n.t("An error has ocurred during the download"));
             }
         }