@owox/backend 0.37.0 → 0.39.0

package/dist/src/data-marts/services/connector/connector-executor.service.js

@@ -18,13 +18,14 @@ const common_1 = require("@nestjs/common");
 const config_1 = require("@nestjs/config");
 const typeorm_1 = require("@nestjs/typeorm");
 const typeorm_2 = require("typeorm");
+const typeorm_transactional_1 = require("typeorm-transactional");
 const connectors_1 = require("@owox/connectors");
 const internal_helpers_1 = require("@owox/internal-helpers");
 const { ConfigDto, GENERATED_REFRESH_TOKEN_CREDENTIAL_FIELD } = connectors_1.Core;
 const GENERATED_REFRESH_TOKEN_MAX_LENGTH = 4096;
 exports.MAX_MERGED_RUN_OUTPUT_ENTRIES = 10000;
 const MAX_MERGED_RUN_OUTPUT_BYTES = 6 * 1024 * 1024;
-const MAX_RUN_BUFFER_ENTRIES = exports.MAX_MERGED_RUN_OUTPUT_ENTRIES - 1;
+const MAX_RUN_BUFFER_ENTRIES = exports.MAX_MERGED_RUN_OUTPUT_ENTRIES - 2;
 const MAX_TRACE_ENTRIES = 1000;
 const data_mart_run_entity_1 = require("../../entities/data-mart-run.entity");
 const data_mart_run_status_enum_1 = require("../../enums/data-mart-run-status.enum");
@@ -42,6 +43,8 @@ const owox_event_dispatcher_1 = require("../../../common/event-dispatcher/owox-e
 const connector_run_event_1 = require("../../events/connector-run.event");
 const project_billing_service_1 = require("../project-billing/project-billing.service");
 const connector_definition_service_1 = require("./connector-definition.service");
+const connector_run_trigger_service_1 = require("./connector-run-trigger.service");
+const backfill_segment_1 = require("./backfill-segment");
 const connector_process_spawner_service_1 = require("./connector-process-spawner.service");
 const connector_storage_config_service_1 = require("./connector-storage-config.service");
 const connector_source_config_service_1 = require("./connector-source-config.service");
@@ -69,8 +72,9 @@ let ConnectorExecutorService = ConnectorExecutorService_1 = class ConnectorExecu
     connectorDefinitionService;
     connectorSourceCredentialsService;
     configService;
+    connectorRunTriggerService;
     logger = new common_1.Logger(ConnectorExecutorService_1.name);
-    constructor(dataMartRunRepository, processSpawner, storageConfigService, sourceConfigService, credentialInjector, connectorOutputCaptureService, connectorStateService, gracefulShutdownService, systemTimeService, eventDispatcher, projectBillingService, dataMartService, connectorDefinitionService, connectorSourceCredentialsService, configService) {
+    constructor(dataMartRunRepository, processSpawner, storageConfigService, sourceConfigService, credentialInjector, connectorOutputCaptureService, connectorStateService, gracefulShutdownService, systemTimeService, eventDispatcher, projectBillingService, dataMartService, connectorDefinitionService, connectorSourceCredentialsService, configService, connectorRunTriggerService) {
         this.dataMartRunRepository = dataMartRunRepository;
         this.processSpawner = processSpawner;
         this.storageConfigService = storageConfigService;
@@ -86,6 +90,7 @@ let ConnectorExecutorService = ConnectorExecutorService_1 = class ConnectorExecu
         this.connectorDefinitionService = connectorDefinitionService;
         this.connectorSourceCredentialsService = connectorSourceCredentialsService;
         this.configService = configService;
+        this.connectorRunTriggerService = connectorRunTriggerService;
     }
     async executeInBackground(dataMart, run, payload, signal) {
         const runId = run.id;
@@ -102,6 +107,8 @@ let ConnectorExecutorService = ConnectorExecutorService_1 = class ConnectorExecu
         let hasAnySuccessfulConfiguration = false;
         let wasCancelled = false;
         let operationBlockedException;
+        const chainMeta = (0, manual_backfill_range_1.readBackfillChainMeta)(run.additionalParams);
+        const segmentWindow = chainMeta ? (0, manual_backfill_range_1.readBackfillRange)((0, manual_backfill_range_1.unwrapRunPayload)(payload)) : undefined;
         try {
             if (this.gracefulShutdownService.isInShutdownMode()) {
                 throw new connector_execution_error_1.ConnectorExecutionError('Skipping connector execution. Application is shutting down.', undefined, { dataMartId: dataMart.id, projectId: dataMart.projectId, runId });
@@ -119,7 +126,12 @@ let ConnectorExecutorService = ConnectorExecutorService_1 = class ConnectorExecu
             }
             logFlusher = this.createRunLogFlusher(runId, liveLogs, liveErrors, hasOutputFromEarlierAttempt);
             logFlusher?.start();
-            configurationResults = await this.runConnectorConfigurations(run, processId, dataMart, payload, signal, liveLogs, liveErrors);
+            if (chainMeta && segmentWindow) {
+                const startedMarker = (0, backfill_segment_1.buildSegmentMarker)(chainMeta, segmentWindow, 'started', this.systemTimeService.now().toISOString());
+                addBoundedMessage(capturedLogs, startedMarker);
+                addBoundedMessage(liveLogs, startedMarker);
+            }
+            configurationResults = await this.runConnectorConfigurations(run, processId, dataMart, payload, signal, liveLogs, liveErrors, chainMeta !== undefined);
             configurationResults.forEach(result => {
                 result.logs.forEach(log => addBoundedMessage(capturedLogs, log));
                 result.errors.forEach(error => addBoundedMessage(capturedErrors, error));
@@ -155,6 +167,37 @@ let ConnectorExecutorService = ConnectorExecutorService_1 = class ConnectorExecu
             }
         }
         finally {
+            const isShuttingDown = this.gracefulShutdownService.isInShutdownMode();
+            const willBeInterrupted = isShuttingDown && !wasCancelled && !allConfigurationsSucceeded;
+            const anyDateProgress = configurationResults.some(result => result.backfillLoadedThrough !== undefined);
+            const chainStep = chainMeta &&
+                !wasCancelled &&
+                signal?.aborted !== true &&
+                !operationBlockedException &&
+                !willBeInterrupted
+                ? (0, manual_backfill_range_1.nextBackfillChainStep)(chainMeta, {
+                    segmentSucceeded: allConfigurationsSucceeded,
+                    anyProgressAdvanced: anyDateProgress,
+                }, (0, manual_backfill_range_1.getMaxManualBackfillDays)())
+                : undefined;
+            const chainContinues = chainStep?.action === 'continue';
+            if (chainMeta && segmentWindow && !wasCancelled && !willBeInterrupted) {
+                const reportedDays = configurationResults.flatMap(result => result.backfillLoadedThrough ? [result.backfillLoadedThrough] : []);
+                const loadedThrough = reportedDays.length > 0 ? reportedDays.reduce((a, b) => (a < b ? a : b)) : undefined;
+                const chainEnd = operationBlockedException
+                    ? 'stopped'
+                    : chainStep?.action === 'end'
+                        ? chainStep.chainEnd
+                        : undefined;
+                (0, connector_message_utils_1.addMessageToArray)(capturedLogs, (0, backfill_segment_1.buildSegmentMarker)(chainMeta, segmentWindow, allConfigurationsSucceeded ? 'completed' : 'failed', this.systemTimeService.now().toISOString(), {
+                    loadedThrough,
+                    configurationsLoaded: reportedDays.length,
+                    configurationsTotal: configurationResults.length,
+                    counted: hasAnySuccessfulConfiguration,
+                    chainContinues,
+                    ...(chainEnd ? { chainEnd } : {}),
+                }));
+            }
             const hasSuccessfulFieldsUpdate = configurationResults.some(result => result.success && result.fieldsUpdate);
             try {
                 await this.persistSuccessfulFieldsUpdate(dataMart, configurationResults, runId);
@@ -180,21 +223,21 @@ let ConnectorExecutorService = ConnectorExecutorService_1 = class ConnectorExecu
             }
             await logFlusher?.stop();
             const flushedSnapshot = logFlusher?.persistedSnapshot() ?? null;
-            const persistedStatus = await this.updateRunStatus(runId, allConfigurationsSucceeded, capturedLogs, capturedErrors, operationBlockedException, wasCancelled, flushedSnapshot);
+            const persistedStatus = await this.updateRunStatus(runId, allConfigurationsSucceeded, capturedLogs, capturedErrors, operationBlockedException, wasCancelled, willBeInterrupted, flushedSnapshot, chainStep?.action === 'continue'
+                ? { run, dataMart, meta: chainStep.meta, window: chainStep.window }
+                : undefined);
             if (hasAnySuccessfulConfiguration &&
                 persistedStatus !== null &&
                 persistedStatus !== data_mart_run_status_enum_1.DataMartRunStatus.INTERRUPTED) {
                 await this.projectBillingService.registerConnectorRunConsumption(dataMart, runId);
             }
-            if (allConfigurationsSucceeded && persistedStatus !== null) {
+            if (persistedStatus === data_mart_run_status_enum_1.DataMartRunStatus.SUCCESS) {
                 await this.eventDispatcher.publishExternal(new connector_run_event_1.ConnectorRunEvent(dataMart.id, runId, dataMart.projectId, run.createdById ?? 'system', run.runType, 'successfully'));
             }
-            else if (persistedStatus !== null &&
-                !wasCancelled &&
-                !this.gracefulShutdownService.isInShutdownMode()) {
+            else if (persistedStatus !== null && !wasCancelled && !willBeInterrupted) {
                 await this.eventDispatcher.publishExternal(new connector_run_event_1.ConnectorRunEvent(dataMart.id, runId, dataMart.projectId, run.createdById ?? 'system', run.runType, 'unsuccessfully'));
             }
-            if (!hasSuccessfulFieldsUpdate) {
+            if (!hasSuccessfulFieldsUpdate && !chainContinues) {
                 await this.actualizeSchemaAfterConnectorExecution(dataMart, runId);
             }
             this.gracefulShutdownService.unregisterActiveProcess(processId);
@@ -225,7 +268,7 @@ let ConnectorExecutorService = ConnectorExecutorService_1 = class ConnectorExecu
             }
         }
     }
-    async runConnectorConfigurations(run, processId, dataMart, payload, signal, liveLogs = [], liveErrors = []) {
+    async runConnectorConfigurations(run, processId, dataMart, payload, signal, liveLogs = [], liveErrors = [], isChainSegment = false) {
         const runId = run.id;
         const definition = dataMart.definition;
         const { connector } = definition;
@@ -549,6 +592,9 @@ let ConnectorExecutorService = ConnectorExecutorService_1 = class ConnectorExecu
                     logs: configLogs,
                     errors: configErrors,
                     fieldsUpdate,
+                    ...(isChainSegment && backfillProgress[configId] !== undefined
+                        ? { backfillLoadedThrough: backfillProgress[configId] }
+                        : {}),
                 });
             }
         }
@@ -742,7 +788,7 @@ let ConnectorExecutorService = ConnectorExecutorService_1 = class ConnectorExecu
             });
         }, error => this.logger.warn(`Incremental log flush failed for run ${runId}: ${(0, internal_helpers_1.castError)(error).message}`));
     }
-    async updateRunStatus(runId, allConfigurationsSucceeded, capturedLogs, capturedErrors, operationBlockedException, wasCancelled = false, flushedSnapshot = null) {
+    async updateRunStatus(runId, allConfigurationsSucceeded, capturedLogs, capturedErrors, operationBlockedException, wasCancelled = false, willBeInterrupted = false, flushedSnapshot = null, nextSegment) {
         let status = wasCancelled
             ? data_mart_run_status_enum_1.DataMartRunStatus.CANCELLED
             : allConfigurationsSucceeded
@@ -750,21 +796,37 @@ let ConnectorExecutorService = ConnectorExecutorService_1 = class ConnectorExecu
                 : operationBlockedException
                     ? data_mart_run_status_enum_1.DataMartRunStatus.RESTRICTED
                     : data_mart_run_status_enum_1.DataMartRunStatus.FAILED;
-        if (!wasCancelled &&
-            !allConfigurationsSucceeded &&
-            this.gracefulShutdownService.isInShutdownMode()) {
+        if (willBeInterrupted) {
             status = data_mart_run_status_enum_1.DataMartRunStatus.INTERRUPTED;
         }
         const newLogStrings = capturedLogs.map(log => JSON.stringify(log));
         const newErrorStrings = capturedErrors.map(error => JSON.stringify(error));
-        const { logs: logsToSave, errors: errorsToSave } = await this.mergeWithPersistedOutput(runId, newLogStrings, newErrorStrings, flushedSnapshot);
-        const result = await this.dataMartRunRepository.update({ id: runId, status: (0, typeorm_2.In)(data_mart_run_cancellation_1.NON_TERMINAL_DATA_MART_RUN_STATUSES) }, {
-            status,
-            finishedAt: this.systemTimeService.now(),
-            logs: logsToSave,
-            errors: errorsToSave,
-        });
-        if (result.affected) {
+        const merged = await this.mergeWithPersistedOutput(runId, newLogStrings, newErrorStrings, flushedSnapshot);
+        let logsToSave = merged.logs;
+        const errorsToSave = merged.errors;
+        let landed;
+        try {
+            landed = await this.writeRunOutcome(runId, status, logsToSave, errorsToSave, nextSegment);
+        }
+        catch (error) {
+            if (!nextSegment)
+                throw error;
+            const failure = (0, internal_helpers_1.castError)(error);
+            this.logger.error(`Failed to queue the next backfill segment: ${failure.message}`, failure.stack, {
+                runId,
+            });
+            const queueWarning = 'Could not queue the next backfill segment. The backfill continues automatically within 15 minutes.';
+            logsToSave = this.capMergedEntries([
+                ...(logsToSave ?? []),
+                JSON.stringify({
+                    type: connector_message_type_enum_1.ConnectorMessageType.WARNING,
+                    at: this.systemTimeService.now().toISOString(),
+                    warning: queueWarning,
+                }),
+            ]);
+            landed = await this.writeRunOutcome(runId, status, logsToSave, errorsToSave);
+        }
+        if (landed) {
             return status;
         }
         this.logger.log(`Skipped final status update for run ${runId}: run already reached a terminal status`);
@@ -773,6 +835,21 @@ let ConnectorExecutorService = ConnectorExecutorService_1 = class ConnectorExecu
         }
         return null;
     }
+    async writeRunOutcome(runId, status, logs, errors, nextSegment) {
+        const result = await this.dataMartRunRepository.update({ id: runId, status: (0, typeorm_2.In)(data_mart_run_cancellation_1.NON_TERMINAL_DATA_MART_RUN_STATUSES) }, { status, finishedAt: this.systemTimeService.now(), logs, errors });
+        if (!result.affected)
+            return false;
+        if (!nextSegment)
+            return true;
+        const { run, dataMart, meta, window } = nextSegment;
+        if (status !== data_mart_run_status_enum_1.DataMartRunStatus.SUCCESS && status !== data_mart_run_status_enum_1.DataMartRunStatus.FAILED) {
+            this.logger.warn(`Not queueing backfill segment ${meta.segmentIndex} of ${meta.segmentsTotal}: run ended ${status}`, { dataMartId: run.dataMartId, projectId: dataMart.projectId, runId });
+            return true;
+        }
+        const nextRun = await (0, backfill_segment_1.createNextSegmentRun)(this.dataMartRunRepository, this.connectorRunTriggerService, run, dataMart, meta, window);
+        this.logger.log(`Queued backfill segment ${meta.segmentIndex} of ${meta.segmentsTotal} as run ${nextRun.id}`, { dataMartId: run.dataMartId, projectId: dataMart.projectId, runId, nextRunId: nextRun.id });
+        return true;
+    }
     async mergeWithPersistedOutput(runId, newLogStrings, newErrorStrings, flushedSnapshot = null) {
         const existing = await this.dataMartRunRepository.findOne({ where: { id: runId } });
         const existingLogs = this.discountFlushedEntries(existing?.logs ?? [], flushedSnapshot?.logs, newLogStrings);
@@ -824,6 +901,12 @@ let ConnectorExecutorService = ConnectorExecutorService_1 = class ConnectorExecu
     }
 };
 exports.ConnectorExecutorService = ConnectorExecutorService;
+__decorate([
+    (0, typeorm_transactional_1.Transactional)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], ConnectorExecutorService.prototype, "writeRunOutcome", null);
 exports.ConnectorExecutorService = ConnectorExecutorService = ConnectorExecutorService_1 = __decorate([
     (0, common_1.Injectable)(),
     __param(0, (0, typeorm_1.InjectRepository)(data_mart_run_entity_1.DataMartRun)),
@@ -841,6 +924,7 @@ exports.ConnectorExecutorService = ConnectorExecutorService = ConnectorExecutorS
         data_mart_service_1.DataMartService,
         connector_definition_service_1.ConnectorDefinitionService,
         connector_source_credentials_service_1.ConnectorSourceCredentialsService,
-        config_1.ConfigService])
+        config_1.ConfigService,
+        connector_run_trigger_service_1.ConnectorRunTriggerService])
 ], ConnectorExecutorService);
 //# sourceMappingURL=connector-executor.service.js.map

package/dist/src/data-marts/services/connector/connector-run.service.d.ts

@@ -17,6 +17,9 @@ export declare class ConnectorRunService {
     executeExistingRun(dataMart: DataMart, run: DataMartRun, payload?: Record<string, unknown> | null, signal?: AbortSignal): Promise<void>;
     getDataMartConnectorRunsByStatus(status: DataMartRunStatus): Promise<DataMartRun[]>;
     executeInterruptedRuns(): Promise<void>;
+    repairBackfillChains(): Promise<void>;
+    private hasLaterRun;
+    private queueChainSegment;
     private validateDataMartForConnector;
     private checkDataMartIsRunning;
     private createDataMartRun;

package/dist/src/data-marts/services/connector/connector-run.service.js

@@ -14,10 +14,12 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 var ConnectorRunService_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConnectorRunService = void 0;
+const node_crypto_1 = require("node:crypto");
 const common_1 = require("@nestjs/common");
 const typeorm_transactional_1 = require("typeorm-transactional");
 const typeorm_1 = require("@nestjs/typeorm");
 const typeorm_2 = require("typeorm");
+const internal_helpers_1 = require("@owox/internal-helpers");
 const business_violation_exception_1 = require("../../../common/exceptions/business-violation.exception");
 const data_mart_entity_1 = require("../../entities/data-mart.entity");
 const data_mart_run_entity_1 = require("../../entities/data-mart-run.entity");
@@ -29,8 +31,11 @@ const connector_execution_error_1 = require("../../errors/connector-execution.er
 const types_1 = require("../../../common/scheduler/shared/types");
 const connector_run_trigger_service_1 = require("./connector-run-trigger.service");
 const connector_executor_service_1 = require("./connector-executor.service");
+const backfill_segment_1 = require("./backfill-segment");
 const system_time_service_1 = require("../../../common/scheduler/services/system-time.service");
 const manual_backfill_range_1 = require("../../utils/manual-backfill-range");
+const CHAIN_REPAIR_LOOKBACK_MS = 24 * 60 * 60 * 1000;
+const CHAIN_SUCCESSOR_CLOCK_SLACK_MS = 60 * 1000;
 let ConnectorRunService = ConnectorRunService_1 = class ConnectorRunService {
     dataMartRunRepository;
     connectorRunTriggerService;
@@ -50,14 +55,16 @@ let ConnectorRunService = ConnectorRunService_1 = class ConnectorRunService {
             throw new business_violation_exception_1.BusinessViolationException('Connector is already running. Please wait until it finishes');
         }
         const preparedPayload = (0, manual_backfill_range_1.prepareManualBackfillPayload)(payload, this.systemTimeService.now());
-        const dataMartRun = await this.createDataMartRun(dataMart, createdById, runType, preparedPayload);
+        const chainPlan = (0, manual_backfill_range_1.planBackfillChain)(preparedPayload, (0, node_crypto_1.randomUUID)());
+        const runPayload = chainPlan?.payload ?? preparedPayload;
+        const dataMartRun = await this.createDataMartRun(dataMart, createdById, runType, runPayload, chainPlan?.meta);
         await this.connectorRunTriggerService.createTrigger({
             dataMartId: dataMart.id,
             projectId: dataMart.projectId,
             createdById,
             dataMartRunId: dataMartRun.id,
             runType,
-            payload: preparedPayload,
+            payload: dataMartRun.additionalParams ?? undefined,
         });
         return dataMartRun.id;
     }
@@ -107,6 +114,85 @@ let ConnectorRunService = ConnectorRunService_1 = class ConnectorRunService {
             }
         }
     }
+    async repairBackfillChains() {
+        const cutoff = new Date(this.systemTimeService.now().getTime() - CHAIN_REPAIR_LOOKBACK_MS);
+        const recent = await this.dataMartRunRepository.find({
+            where: {
+                type: data_mart_run_type_enum_1.DataMartRunType.CONNECTOR,
+                status: (0, typeorm_2.In)([data_mart_run_status_enum_1.DataMartRunStatus.SUCCESS, data_mart_run_status_enum_1.DataMartRunStatus.FAILED]),
+                runType: types_1.RunType.manual,
+                finishedAt: (0, typeorm_2.MoreThanOrEqual)(cutoff),
+            },
+            select: [
+                'id',
+                'dataMartId',
+                'status',
+                'runType',
+                'createdById',
+                'finishedAt',
+                'additionalParams',
+            ],
+        });
+        const latestByChain = new Map();
+        for (const run of recent) {
+            const meta = (0, manual_backfill_range_1.readBackfillChainMeta)(run.additionalParams);
+            if (!meta)
+                continue;
+            const current = latestByChain.get(meta.id);
+            if (!current || meta.segmentIndex > current.meta.segmentIndex) {
+                latestByChain.set(meta.id, { run, meta });
+            }
+        }
+        for (const { run, meta } of latestByChain.values()) {
+            try {
+                const step = (0, manual_backfill_range_1.nextBackfillChainStep)(meta, {
+                    segmentSucceeded: run.status === data_mart_run_status_enum_1.DataMartRunStatus.SUCCESS,
+                    anyProgressAdvanced: Object.keys((0, manual_backfill_range_1.readBackfillProgress)(run.additionalParams)).length > 0,
+                }, (0, manual_backfill_range_1.getMaxManualBackfillDays)());
+                if (step.action !== 'continue')
+                    continue;
+                if (await this.hasLaterRun(run, meta))
+                    continue;
+                const withDataMart = await this.dataMartRunRepository.findOne({
+                    where: { id: run.id },
+                    relations: ['dataMart'],
+                });
+                if (!withDataMart?.dataMart || (await this.checkDataMartIsRunning(withDataMart.dataMart))) {
+                    continue;
+                }
+                const nextRunId = await this.queueChainSegment(withDataMart, step.meta, step.window);
+                this.logger.log(`Repaired backfill chain ${meta.id}: queued segment ${step.meta.segmentIndex} of ${step.meta.segmentsTotal} as run ${nextRunId}`, { dataMartId: run.dataMartId, runId: run.id, nextRunId });
+            }
+            catch (error) {
+                const failure = (0, internal_helpers_1.castError)(error);
+                this.logger.error(`Failed to repair backfill chain ${meta.id}: ${failure.message}`, failure.stack, { dataMartId: run.dataMartId, runId: run.id });
+            }
+        }
+    }
+    async hasLaterRun(run, meta) {
+        if (!run.finishedAt)
+            return true;
+        const since = new Date(run.finishedAt.getTime() - CHAIN_SUCCESSOR_CLOCK_SLACK_MS);
+        const candidates = await this.dataMartRunRepository.find({
+            where: {
+                dataMartId: run.dataMartId,
+                type: data_mart_run_type_enum_1.DataMartRunType.CONNECTOR,
+                id: (0, typeorm_2.Not)(run.id),
+                createdAt: (0, typeorm_2.MoreThanOrEqual)(since),
+            },
+            select: ['id', 'additionalParams'],
+        });
+        return candidates.some(candidate => {
+            const candidateMeta = (0, manual_backfill_range_1.readBackfillChainMeta)(candidate.additionalParams);
+            if (candidateMeta?.id === meta.id)
+                return candidateMeta.segmentIndex > meta.segmentIndex;
+            return (0, manual_backfill_range_1.isManualBackfillPayload)((0, manual_backfill_range_1.unwrapRunPayload)(candidate.additionalParams));
+        });
+    }
+    async queueChainSegment(run, meta, window) {
+        const nextRun = await (0, backfill_segment_1.createNextSegmentRun)(this.dataMartRunRepository, this.connectorRunTriggerService, run, run.dataMart, meta, window);
+        return nextRun.id;
+    }
     validateDataMartForConnector(dataMart) {
         if (dataMart.definitionType !== data_mart_definition_type_enum_1.DataMartDefinitionType.CONNECTOR) {
             throw new connector_execution_error_1.ConnectorExecutionError('DataMart is not a connector type', undefined, {
@@ -131,7 +217,7 @@ let ConnectorRunService = ConnectorRunService_1 = class ConnectorRunService {
         });
         return !!dataMartRun;
     }
-    async createDataMartRun(dataMart, createdById, runType, payload) {
+    async createDataMartRun(dataMart, createdById, runType, payload, chainMeta) {
         const dataMartRun = this.dataMartRunRepository.create({
             dataMartId: dataMart.id,
             type: data_mart_run_type_enum_1.DataMartRunType.CONNECTOR,
@@ -141,7 +227,9 @@ let ConnectorRunService = ConnectorRunService_1 = class ConnectorRunService {
             runType,
             logs: [],
             errors: [],
-            additionalParams: payload ? { payload } : undefined,
+            additionalParams: payload
+                ? { payload, ...(chainMeta ? { [manual_backfill_range_1.BACKFILL_CHAIN_KEY]: chainMeta } : {}) }
+                : undefined,
         });
         return this.dataMartRunRepository.save(dataMartRun);
     }
@@ -153,6 +241,12 @@ __decorate([
     __metadata("design:paramtypes", [data_mart_entity_1.DataMart, String, String, Object]),
     __metadata("design:returntype", Promise)
 ], ConnectorRunService.prototype, "run", null);
+__decorate([
+    (0, typeorm_transactional_1.Transactional)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [data_mart_run_entity_1.DataMartRun, Object, Object]),
+    __metadata("design:returntype", Promise)
+], ConnectorRunService.prototype, "queueChainSegment", null);
 exports.ConnectorRunService = ConnectorRunService = ConnectorRunService_1 = __decorate([
     (0, common_1.Injectable)(),
     __param(0, (0, typeorm_1.InjectRepository)(data_mart_run_entity_1.DataMartRun)),

package/dist/src/data-marts/services/context/context.service.d.ts

@@ -21,6 +21,8 @@ export declare class ContextService {
     private readonly userProjectionsFetcherService;
     constructor(contextRepository: Repository<Context>, dataMartContextRepository: Repository<DataMartContext>, storageContextRepository: Repository<StorageContext>, destinationContextRepository: Repository<DestinationContext>, memberRoleContextRepository: Repository<MemberRoleContext>, memberRoleScopeRepository: Repository<MemberRoleScope>, userProvisioningContextSettingsContextRepository: Repository<UserProvisioningContextSettingsContext>, contextMapper: ContextMapper, userProjectionsFetcherService: UserProjectionsFetcherService);
     create(projectId: string, createdById: string, name: string, description?: string): Promise<ContextDto>;
+    listForMcp(projectId: string): Promise<import("../../facades/mcp-contexts.facade").McpContext[]>;
+    getDataMartContextSummaries(projectId: string, dataMartIds: string[]): Promise<Record<string, import("../../facades/mcp-contexts.facade").McpContextSummary[]>>;
     list(projectId: string): Promise<ContextDto[]>;
     update(contextId: string, projectId: string, name: string, description?: string): Promise<ContextDto>;
     getImpact(contextId: string, projectId: string): Promise<ContextImpactDto>;

package/dist/src/data-marts/services/context/context.service.js

@@ -85,6 +85,27 @@ let ContextService = class ContextService {
         const userProjections = await this.userProjectionsFetcherService.fetchUserProjectionsList(saved.createdById ? [saved.createdById] : []);
         return this.contextMapper.toDomainDto(saved, userProjections);
     }
+    async listForMcp(projectId) {
+        const entities = await this.contextRepository.find({
+            where: { projectId },
+            order: { name: 'ASC' },
+        });
+        return entities.map(entity => this.contextMapper.toMcpContext(entity));
+    }
+    async getDataMartContextSummaries(projectId, dataMartIds) {
+        if (dataMartIds.length === 0)
+            return {};
+        const rows = await this.dataMartContextRepository.find({
+            where: {
+                dataMartId: (0, typeorm_2.In)([...new Set(dataMartIds)]),
+                context: { projectId },
+                dataMart: { projectId },
+            },
+            relations: ['context'],
+            order: { context: { name: 'ASC' } },
+        });
+        return this.contextMapper.toDataMartContextSummaries(rows);
+    }
     async list(projectId) {
         const entities = await this.contextRepository.find({
             where: { projectId },

package/dist/src/data-marts/services/data-mart-run.service.d.ts

@@ -86,6 +86,7 @@ export declare class DataMartRunService {
     findById(runId: string): Promise<DataMartRun | null>;
     getByIdAndDataMartId(runId: string, dataMartId: string): Promise<DataMartRun | null>;
     getDataQualityDetailsByIdAndDataMartId(runId: string, dataMartId: string): Promise<DataMartRun | null>;
+    findActiveConnectorRun(dataMartId: string): Promise<DataMartRun | null>;
     markAsCancelled(dataMartRun: DataMartRun): Promise<boolean>;
     createAndMarkReportRunAsPending(report: Report, context: ReportRunContext): Promise<DataMartRun>;
     createAndMarkReportRunAsStarted(report: Report, context: ReportRunContext): Promise<DataMartRun>;

package/dist/src/data-marts/services/data-mart-run.service.js

@@ -129,6 +129,15 @@ let DataMartRunService = DataMartRunService_1 = class DataMartRunService {
             .andWhere('run.dataMartId = :dataMartId', { dataMartId })
             .getOne();
     }
+    async findActiveConnectorRun(dataMartId) {
+        return this.dataMartRunRepository.findOne({
+            where: {
+                dataMartId,
+                type: data_mart_run_type_enum_1.DataMartRunType.CONNECTOR,
+                status: (0, typeorm_2.In)([data_mart_run_status_enum_1.DataMartRunStatus.PENDING, data_mart_run_status_enum_1.DataMartRunStatus.RUNNING]),
+            },
+        });
+    }
     async markAsCancelled(dataMartRun) {
         const result = await this.dataMartRunRepository.update({
             id: dataMartRun.id,

package/dist/src/data-marts/services/data-mart.service.d.ts

@@ -28,6 +28,7 @@ export declare class DataMartService {
         roles?: string[];
         roleScope?: RoleScope;
         status?: DataMartStatus;
+        contextIds?: string[];
     }): Promise<{
         items: DataMart[];
         total: number;

package/dist/src/data-marts/services/data-mart.service.js

@@ -112,6 +112,9 @@ let DataMartService = DataMartService_1 = class DataMartService {
         if (options?.status) {
             qb.andWhere('dm.status = :status', { status: options.status });
         }
+        if (options?.contextIds?.length) {
+            qb.andWhere('EXISTS (SELECT 1 FROM data_mart_contexts filteredContext WHERE filteredContext.data_mart_id = dm.id AND filteredContext.context_id IN (:...filterContextIds))', { filterContextIds: options.contextIds });
+        }
         this.applyNonAdminVisibilityGate(qb, projectId, options);
         if (options?.ownerFilter === owner_filter_enum_1.OwnerFilter.HAS_OWNERS) {
             qb.andWhere(`(EXISTS (SELECT 1 FROM data_mart_technical_owners t WHERE t.data_mart_id = dm.id)

package/dist/src/data-marts/system-triggers/processors/repair-backfill-chains-processor.d.ts

@@ -0,0 +1,14 @@
+import { SystemTrigger } from '../../../common/scheduler/shared/entities/system-trigger.entity';
+import { BaseSystemTaskProcessor } from '../../../common/scheduler/system-tasks/base-system-task.processor';
+import { SystemTriggerType } from '../../../common/scheduler/system-tasks/system-trigger-type';
+import { ConnectorExecutionService } from '../../services/connector/connector-execution.service';
+export declare class RepairBackfillChainsProcessor extends BaseSystemTaskProcessor {
+    private readonly connectorExecutionService;
+    private readonly logger;
+    constructor(connectorExecutionService: ConnectorExecutionService);
+    getType(): SystemTriggerType;
+    getDefaultCron(): string;
+    process(_trigger: SystemTrigger, options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+}

package/dist/src/data-marts/system-triggers/processors/repair-backfill-chains-processor.js

@@ -0,0 +1,45 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var RepairBackfillChainsProcessor_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RepairBackfillChainsProcessor = void 0;
+const common_1 = require("@nestjs/common");
+const base_system_task_processor_1 = require("../../../common/scheduler/system-tasks/base-system-task.processor");
+const system_trigger_type_1 = require("../../../common/scheduler/system-tasks/system-trigger-type");
+const connector_execution_service_1 = require("../../services/connector/connector-execution.service");
+let RepairBackfillChainsProcessor = RepairBackfillChainsProcessor_1 = class RepairBackfillChainsProcessor extends base_system_task_processor_1.BaseSystemTaskProcessor {
+    connectorExecutionService;
+    logger = new common_1.Logger(RepairBackfillChainsProcessor_1.name);
+    constructor(connectorExecutionService) {
+        super();
+        this.connectorExecutionService = connectorExecutionService;
+    }
+    getType() {
+        return system_trigger_type_1.SystemTriggerType.REPAIR_BACKFILL_CHAINS;
+    }
+    getDefaultCron() {
+        return '0 */15 * * * *';
+    }
+    async process(_trigger, options) {
+        if (options?.signal?.aborted) {
+            this.logger.debug('Backfill chain repair aborted before start');
+            return;
+        }
+        this.logger.debug('Executing backfill chain repair');
+        await this.connectorExecutionService.repairBackfillChains();
+    }
+};
+exports.RepairBackfillChainsProcessor = RepairBackfillChainsProcessor;
+exports.RepairBackfillChainsProcessor = RepairBackfillChainsProcessor = RepairBackfillChainsProcessor_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [connector_execution_service_1.ConnectorExecutionService])
+], RepairBackfillChainsProcessor);
+//# sourceMappingURL=repair-backfill-chains-processor.js.map

package/dist/src/data-marts/use-cases/cancel-data-mart-run.service.d.ts

@@ -16,9 +16,13 @@ export declare class CancelDataMartRunService {
     private readonly accessDecisionService;
     constructor(dataMartService: DataMartService, dataMartRunService: DataMartRunService, connectorRunTriggerService: ConnectorRunTriggerService, reportRunTriggerService: ReportRunTriggerService, dataQualityRunService: DataQualityRunService, reportService: ReportService, accessDecisionService: AccessDecisionService);
     run(command: CancelDataMartRunCommand): Promise<void>;
+    private findChainMeta;
     private cancelRunState;
     private isSupportedRunType;
     private isStandardReportRun;
     private markActiveRunAsCancelled;
+    private cancelChainRun;
+    private resolveChainTarget;
+    private cancelChainRunState;
     private getStandardReportRunReportId;
 }