@owox/backend 0.37.0 → 0.39.0

package/dist/src/data-marts/data-storage-types/snowflake/adapters/snowflake-api.adapter.js

@@ -51,6 +51,7 @@ class SnowflakeApiAdapter {
             warehouse: config.warehouse,
             retryTimeout: 10000,
             sfRetryMaxLoginRetries: 1,
+            certRevocationCheckMode: 'ADVISORY',
         };
         if (credentials.authMethod === snowflake_auth_method_enum_1.SnowflakeAuthMethod.PASSWORD) {
             connectionOptions.username = credentials.username;

package/dist/src/data-marts/data-storage-types/snowflake/services/snowflake-access.validator.js

@@ -21,14 +21,12 @@ let SnowflakeAccessValidator = SnowflakeAccessValidator_1 = class SnowflakeAcces
         const configOpt = snowflake_config_schema_1.SnowflakeConfigSchema.safeParse(config);
         if (!configOpt.success) {
             this.logger.log('Invalid config', configOpt.error);
-            return new data_storage_access_validator_interface_1.ValidationResult(false, 'Invalid config', { errors: configOpt.error.errors });
+            return data_storage_access_validator_interface_1.ValidationResult.invalidInput('config', configOpt.error);
         }
         const credentialsOpt = snowflake_credentials_schema_1.SnowflakeCredentialsSchema.safeParse(credentials);
         if (!credentialsOpt.success) {
             this.logger.log('Invalid credentials', credentialsOpt.error);
-            return new data_storage_access_validator_interface_1.ValidationResult(false, 'Invalid credentials', {
-                errors: credentialsOpt.error.errors,
-            });
+            return data_storage_access_validator_interface_1.ValidationResult.invalidInput('credentials', credentialsOpt.error);
         }
         const snowflakeConfig = configOpt.data;
         const apiAdapter = new snowflake_api_adapter_1.SnowflakeApiAdapter(credentialsOpt.data, snowflakeConfig);

package/dist/src/data-marts/dto/domain/list-data-marts.command.d.ts

@@ -7,5 +7,6 @@ export declare class ListDataMartsCommand {
     readonly offset?: number | undefined;
     readonly ownerFilter?: OwnerFilter | undefined;
     readonly status?: DataMartStatus | undefined;
-    constructor(projectId: string, userId: string, roles: string[], offset?: number | undefined, ownerFilter?: OwnerFilter | undefined, status?: DataMartStatus | undefined);
+    readonly contextIds?: string[] | undefined;
+    constructor(projectId: string, userId: string, roles: string[], offset?: number | undefined, ownerFilter?: OwnerFilter | undefined, status?: DataMartStatus | undefined, contextIds?: string[] | undefined);
 }

package/dist/src/data-marts/dto/domain/list-data-marts.command.js

@@ -8,13 +8,15 @@ class ListDataMartsCommand {
     offset;
     ownerFilter;
     status;
-    constructor(projectId, userId, roles, offset, ownerFilter, status) {
+    contextIds;
+    constructor(projectId, userId, roles, offset, ownerFilter, status, contextIds) {
         this.projectId = projectId;
         this.userId = userId;
         this.roles = roles;
         this.offset = offset;
         this.ownerFilter = ownerFilter;
         this.status = status;
+        this.contextIds = contextIds;
     }
 }
 exports.ListDataMartsCommand = ListDataMartsCommand;

package/dist/src/data-marts/dto/presentation/run-data-mart-request-api.dto.js

@@ -171,8 +171,10 @@ __decorate([
         description: `Payload for the manual run. Omit it or select INCREMENTAL for an incremental run.
     MANUAL_BACKFILL can include connector-specific fields in data; connectors without backfill
     fields can omit data. StartDate and EndDate accept YYYY-MM-DD (or the date part of an
-    ISO-8601 timestamp). A missing or future EndDate counts as today, and the resulting range
-    may cover at most 31 days.`,
+    ISO-8601 timestamp). A missing or future EndDate counts as today. A StartDate earlier than
+    2000-01-01 is rejected. The range has no other length limit: a range longer than 31 days runs
+    as a chain of runs, one segment of up to 31 days each. A segment counts as one connector run
+    once any of its accounts loads data.`,
     }),
     __metadata("design:type", Object)
 ], RunDataMartRequestApiDto.prototype, "payload", void 0);

package/dist/src/data-marts/dto/presentation/sql-dry-run-request-api.dto.js

@@ -12,6 +12,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SqlDryRunRequestApiDto = void 0;
 const swagger_1 = require("@nestjs/swagger");
 const class_validator_1 = require("class-validator");
+const max_byte_length_validator_1 = require("../../../common/validators/max-byte-length.validator");
+const MAX_MEDIUMTEXT_COLUMN_BYTES = 16777215;
 class SqlDryRunRequestApiDto {
     sql;
 }
@@ -23,6 +25,7 @@ __decorate([
     }),
     (0, class_validator_1.IsString)(),
     (0, class_validator_1.IsNotEmpty)(),
+    (0, max_byte_length_validator_1.MaxByteLength)(MAX_MEDIUMTEXT_COLUMN_BYTES),
     __metadata("design:type", String)
 ], SqlDryRunRequestApiDto.prototype, "sql", void 0);
 //# sourceMappingURL=sql-dry-run-request-api.dto.js.map

package/dist/src/data-marts/dto/presentation/storage-resources/list-storage-resources-response.dto.d.ts

@@ -7,6 +7,8 @@ export declare class StorageResourceLeafDto {
     groupId: string;
     type: 'TABLE' | 'VIEW';
     fullyQualifiedName: string;
+    location?: string;
+    locationMismatch?: boolean;
 }
 export declare class ListStorageResourcesResponseDto {
     namespaces?: StorageNamespaceNodeDto[];

package/dist/src/data-marts/dto/presentation/storage-resources/list-storage-resources-response.dto.js

@@ -35,6 +35,8 @@ class StorageResourceLeafDto {
     groupId;
     type;
     fullyQualifiedName;
+    location;
+    locationMismatch;
 }
 exports.StorageResourceLeafDto = StorageResourceLeafDto;
 __decorate([
@@ -59,6 +61,21 @@ __decorate([
     }),
     __metadata("design:type", String)
 ], StorageResourceLeafDto.prototype, "fullyQualifiedName", void 0);
+__decorate([
+    (0, swagger_1.ApiPropertyOptional)({
+        description: "Where the resource's data lives, e.g. a BigQuery dataset location",
+        example: 'EU',
+    }),
+    __metadata("design:type", String)
+], StorageResourceLeafDto.prototype, "location", void 0);
+__decorate([
+    (0, swagger_1.ApiPropertyOptional)({
+        description: 'True when the resource lives in a different location than the one the storage runs ' +
+            'queries in, so a data mart on this storage cannot read it. Omitted when either ' +
+            'location is unknown.',
+    }),
+    __metadata("design:type", Boolean)
+], StorageResourceLeafDto.prototype, "locationMismatch", void 0);
 class ListStorageResourcesResponseDto {
     namespaces;
     resources;

package/dist/src/data-marts/errors/google-sheets-api-call.error.d.ts

@@ -0,0 +1,6 @@
+export declare class GoogleSheetsApiCallError extends Error {
+    readonly status: number;
+    readonly cause: unknown;
+    constructor(message: string, status: number, cause: unknown);
+}
+export declare function googleSheetsApiCallMessage(step: string, status: number, googleMessage: string): string;

package/dist/src/data-marts/errors/google-sheets-api-call.error.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoogleSheetsApiCallError = void 0;
+exports.googleSheetsApiCallMessage = googleSheetsApiCallMessage;
+class GoogleSheetsApiCallError extends Error {
+    status;
+    cause;
+    constructor(message, status, cause) {
+        super(message);
+        this.status = status;
+        this.cause = cause;
+        this.name = 'GoogleSheetsApiCallError';
+    }
+}
+exports.GoogleSheetsApiCallError = GoogleSheetsApiCallError;
+function isUnfinishedUpdate(status) {
+    return status === 404 || status >= 500;
+}
+function googleSheetsApiCallMessage(step, status, googleMessage) {
+    const details = `Details: ${googleMessage.trim()}`;
+    if (isUnfinishedUpdate(status)) {
+        return (`Google Sheets couldn't finish updating the spreadsheet this report writes to. ` +
+            `A single failure can be a temporary problem on Google's side — run the report ` +
+            `again. If it fails on every run, the spreadsheet most likely recalculates heavy ` +
+            `formulas after every change, for example formulas on other sheets that read whole ` +
+            `columns of the report's sheet: limit them to the rows they need or send the report ` +
+            `to a separate spreadsheet. Circular references can cause this too: fix the formulas ` +
+            `that show a circular dependency error, and turn on Iterative calculation ` +
+            `(File → Settings → Calculation) only if a circular reference is intentional. ${details}`);
+    }
+    const whileStep = `while ${step.charAt(0).toLowerCase()}${step.slice(1)}`;
+    return `Google Sheets rejected an update ${whileStep}. ${details}`;
+}
+//# sourceMappingURL=google-sheets-api-call.error.js.map

package/dist/src/data-marts/facades/mcp-contexts.facade.d.ts

@@ -0,0 +1,13 @@
+export declare const MCP_CONTEXTS_FACADE: unique symbol;
+export interface McpContextSummary {
+    id: string;
+    name: string;
+}
+export interface McpContext extends McpContextSummary {
+    description: string | null;
+}
+export interface McpContextsFacade {
+    listContexts(projectId: string): Promise<McpContext[]>;
+    validateContextIds(projectId: string, contextIds: string[]): Promise<void>;
+    getDataMartContexts(projectId: string, dataMartIds: string[]): Promise<Record<string, McpContextSummary[]>>;
+}

package/dist/src/data-marts/facades/mcp-contexts.facade.impl.d.ts

@@ -0,0 +1,9 @@
+import { ContextService } from '../services/context/context.service';
+import type { McpContextsFacade, McpContext, McpContextSummary } from './mcp-contexts.facade';
+export declare class McpContextsFacadeImpl implements McpContextsFacade {
+    private readonly contexts;
+    constructor(contexts: ContextService);
+    listContexts(projectId: string): Promise<McpContext[]>;
+    validateContextIds(projectId: string, contextIds: string[]): Promise<void>;
+    getDataMartContexts(projectId: string, dataMartIds: string[]): Promise<Record<string, McpContextSummary[]>>;
+}

package/dist/src/data-marts/facades/mcp-contexts.facade.impl.js

@@ -0,0 +1,35 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.McpContextsFacadeImpl = void 0;
+const common_1 = require("@nestjs/common");
+const context_service_1 = require("../services/context/context.service");
+let McpContextsFacadeImpl = class McpContextsFacadeImpl {
+    contexts;
+    constructor(contexts) {
+        this.contexts = contexts;
+    }
+    listContexts(projectId) {
+        return this.contexts.listForMcp(projectId);
+    }
+    validateContextIds(projectId, contextIds) {
+        return this.contexts.validateContextIds([...new Set(contextIds)], projectId);
+    }
+    getDataMartContexts(projectId, dataMartIds) {
+        return this.contexts.getDataMartContextSummaries(projectId, dataMartIds);
+    }
+};
+exports.McpContextsFacadeImpl = McpContextsFacadeImpl;
+exports.McpContextsFacadeImpl = McpContextsFacadeImpl = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [context_service_1.ContextService])
+], McpContextsFacadeImpl);
+//# sourceMappingURL=mcp-contexts.facade.impl.js.map

package/dist/src/data-marts/facades/mcp-contexts.facade.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MCP_CONTEXTS_FACADE = void 0;
+exports.MCP_CONTEXTS_FACADE = Symbol('MCP_CONTEXTS_FACADE');
+//# sourceMappingURL=mcp-contexts.facade.js.map

package/dist/src/data-marts/facades/mcp-data-marts.facade.d.ts

@@ -11,6 +11,7 @@ export interface McpListDataMartsRequest {
     userId: string;
     roles: string[];
     status?: McpDataMartCatalogStatus;
+    contextIds?: string[];
 }
 export interface McpSummarizeDataCatalogRequest {
     projectId: string;
@@ -31,6 +32,10 @@ export interface McpDataMartListItem {
     description: string | null;
     status: string;
     updatedAt: string;
+    contexts: Array<{
+        id: string;
+        name: string;
+    }>;
 }
 export interface McpListDataMartsResponse {
     dataMarts: McpDataMartListItem[];
@@ -60,6 +65,10 @@ export interface McpJoinDto {
     description?: string;
 }
 export interface McpDataMartDetailsResponse {
+    contexts: Array<{
+        id: string;
+        name: string;
+    }>;
     id: string;
     name: string;
     description: string;

package/dist/src/data-marts/facades/mcp-data-marts.facade.impl.js

@@ -14,6 +14,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 var McpDataMartsFacadeImpl_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.McpDataMartsFacadeImpl = void 0;
+const extract_context_summaries_1 = require("../utils/extract-context-summaries");
 const common_1 = require("@nestjs/common");
 const internal_helpers_1 = require("@owox/internal-helpers");
 const type_resolver_1 = require("../../common/resolver/type-resolver");
@@ -60,7 +61,7 @@ let McpDataMartsFacadeImpl = McpDataMartsFacadeImpl_1 = class McpDataMartsFacade
     }
     async listDataMarts(request) {
         const status = request.status === 'draft' ? data_mart_status_enum_1.DataMartStatus.DRAFT : data_mart_status_enum_1.DataMartStatus.PUBLISHED;
-        const result = await this.listDataMartsService.run(new list_data_marts_command_1.ListDataMartsCommand(request.projectId, request.userId, request.roles, undefined, undefined, status));
+        const result = await this.listDataMartsService.run(new list_data_marts_command_1.ListDataMartsCommand(request.projectId, request.userId, request.roles, undefined, undefined, status, request.contextIds));
         return {
             dataMarts: result.items
                 .filter(item => item.status === status)
@@ -70,6 +71,7 @@ let McpDataMartsFacadeImpl = McpDataMartsFacadeImpl_1 = class McpDataMartsFacade
                 description: item.description,
                 status: item.status,
                 updatedAt: item.modifiedAt.toISOString(),
+                contexts: item.contexts ?? [],
             })),
         };
     }
@@ -93,6 +95,7 @@ let McpDataMartsFacadeImpl = McpDataMartsFacadeImpl_1 = class McpDataMartsFacade
         return {
             id: dataMart.id,
             name: dataMart.title,
+            contexts: (0, extract_context_summaries_1.extractContextSummaries)(dataMart.contexts),
             description: dataMart.description ?? '',
             fields: this.withDisplayNames(schema?.fields ?? []),
             joinedFields,

package/dist/src/data-marts/mappers/context.mapper.d.ts

@@ -1,8 +1,12 @@
+import type { McpContext, McpContextSummary } from '../facades/mcp-contexts.facade';
+import type { DataMartContext } from '../entities/data-mart-context.entity';
 import { UserProjectionsListDto } from '../../idp/dto/domain/user-projections-list.dto';
 import { ContextDto } from '../dto/domain/context.dto';
 import { ContextResponseApiDto } from '../dto/presentation/context-api.dto';
 import { Context } from '../entities/context.entity';
 export declare class ContextMapper {
+    toMcpContext(entity: Context): McpContext;
+    toDataMartContextSummaries(rows: DataMartContext[]): Record<string, McpContextSummary[]>;
     toDomainDto(entity: Context, userProjections?: UserProjectionsListDto): ContextDto;
     toApiResponse(dto: ContextDto): ContextResponseApiDto;
 }

package/dist/src/data-marts/mappers/context.mapper.js

@@ -10,6 +10,18 @@ exports.ContextMapper = void 0;
 const common_1 = require("@nestjs/common");
 const context_dto_1 = require("../dto/domain/context.dto");
 let ContextMapper = class ContextMapper {
+    toMcpContext(entity) {
+        return { id: entity.id, name: entity.name, description: entity.description || null };
+    }
+    toDataMartContextSummaries(rows) {
+        const result = {};
+        for (const row of rows) {
+            if (!row.context || row.context.deletedAt)
+                continue;
+            (result[row.dataMartId] ??= []).push({ id: row.context.id, name: row.context.name });
+        }
+        return result;
+    }
     toDomainDto(entity, userProjections) {
         const projection = entity.createdById && userProjections
             ? userProjections.getByUserId(entity.createdById)

package/dist/src/data-marts/search/engine/advanced-search.service.js

@@ -59,6 +59,7 @@ let AdvancedSearchService = AdvancedSearchService_1 = class AdvancedSearchServic
             vectorCandidateLimit: this.config.vectorCandidateMultiplier * topK,
             accessScope: options.accessScope,
             excludeDrafts: options.excludeDrafts,
+            ...(options.contextIds?.length ? { contextIds: options.contextIds } : {}),
         };
         const perTypeResults = await Promise.all(activeTypes.map(entityType => this.vectorSearch.search(entityType, projectId, prompt, promptVec, searchOptions)));
         const all = perTypeResults

package/dist/src/data-marts/search/engine/in-memory-paginated.search.js

@@ -12,6 +12,7 @@ var InMemoryPaginatedSearch_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InMemoryPaginatedSearch = void 0;
 const common_1 = require("@nestjs/common");
+const search_facade_1 = require("../../../common/search/search.facade");
 const indexable_source_registry_1 = require("../sources/indexable-source.registry");
 const search_index_repository_1 = require("../schema/search-index.repository");
 const document_builder_1 = require("../indexing/document-builder");
@@ -102,7 +103,22 @@ let InMemoryPaginatedSearch = InMemoryPaginatedSearch_1 = class InMemoryPaginate
             excludeDrafts: options.excludeDrafts === true,
         }));
         const promptTokens = (0, tokenizer_1.tokenizePrompt)(prompt, entityType);
-        const predicate = await source.accessPredicateProvider.build('idx', projectId, options.accessScope);
+        const accessPredicate = await source.accessPredicateProvider.build('idx', projectId, options.accessScope);
+        const predicate = { ...accessPredicate, parameters: { ...accessPredicate.parameters } };
+        if (entityType === search_facade_1.SearchableEntityType.DATA_MART && options.contextIds?.length) {
+            const contextParameters = Object.fromEntries(options.contextIds.map((id, i) => [`filterContext${String(i)}`, id]));
+            const placeholders = Object.keys(contextParameters)
+                .map(key => `:${key}`)
+                .join(', ');
+            predicate.whereSql = [
+                predicate.whereSql,
+                `EXISTS (SELECT 1 FROM data_mart_contexts filteredContext WHERE filteredContext.data_mart_id = idx.entity_id AND filteredContext.context_id IN (${placeholders}))`,
+            ]
+                .filter(Boolean)
+                .map(sql => `(${sql})`)
+                .join(' AND ');
+            Object.assign(predicate.parameters, contextParameters);
+        }
         const buffer = new top_k_buffer_1.TopKBuffer(options.topK);
         const page = await this.repository.searchCandidates(entityType, projectId, predicate, prompt, {
             candidateLimit: options.candidateLimit,

package/dist/src/data-marts/search/engine/vector-search.port.d.ts

@@ -20,6 +20,7 @@ export interface VectorSearchOptions {
     vectorCandidateLimit?: number;
     accessScope?: SourceAccessScope;
     excludeDrafts?: boolean;
+    contextIds?: string[];
 }
 export interface VectorSearchPort {
     search(entityType: SearchableEntityType, projectId: string, prompt: string, promptVec: Float32Array | null, options: VectorSearchOptions): Promise<ScoredEntity[]>;

package/dist/src/data-marts/services/connector/backfill-segment.d.ts

@@ -0,0 +1,22 @@
+import { Repository } from 'typeorm';
+import { ConnectorMessage } from '../../connector-types/connector-message/schemas/connector-message.schema';
+import { ConnectorMessageType } from '../../connector-types/enums/connector-message-type-enum';
+import { DataMart } from '../../entities/data-mart.entity';
+import { DataMartRun } from '../../entities/data-mart-run.entity';
+import { BackfillChainMeta, BackfillDateRange } from '../../utils/manual-backfill-range';
+import { ConnectorRunTriggerService } from './connector-run-trigger.service';
+export declare const BACKFILL_SEGMENT_METRIC = "backfill_segment";
+export type SegmentMarkerPhase = 'started' | 'completed' | 'failed';
+export type SegmentChainEnd = 'finished' | 'stopped';
+export interface SegmentMarkerOutcome {
+    readonly loadedThrough?: string;
+    readonly configurationsLoaded?: number;
+    readonly configurationsTotal?: number;
+    readonly counted?: boolean;
+    readonly chainContinues?: boolean;
+    readonly chainEnd?: SegmentChainEnd;
+}
+export declare function buildSegmentMarker(meta: BackfillChainMeta, window: BackfillDateRange, phase: SegmentMarkerPhase, at: string, outcome?: SegmentMarkerOutcome): Extract<ConnectorMessage, {
+    type: ConnectorMessageType.LOG;
+}>;
+export declare function createNextSegmentRun(runRepository: Repository<DataMartRun>, triggerService: ConnectorRunTriggerService, previousRun: DataMartRun, dataMart: DataMart, meta: BackfillChainMeta, window: BackfillDateRange): Promise<DataMartRun>;

package/dist/src/data-marts/services/connector/backfill-segment.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BACKFILL_SEGMENT_METRIC = void 0;
+exports.buildSegmentMarker = buildSegmentMarker;
+exports.createNextSegmentRun = createNextSegmentRun;
+const connector_message_type_enum_1 = require("../../connector-types/enums/connector-message-type-enum");
+const data_mart_run_status_enum_1 = require("../../enums/data-mart-run-status.enum");
+const data_mart_run_type_enum_1 = require("../../enums/data-mart-run-type.enum");
+const manual_backfill_range_1 = require("../../utils/manual-backfill-range");
+exports.BACKFILL_SEGMENT_METRIC = 'backfill_segment';
+function describeLoadedDays(outcome) {
+    if (!outcome.loadedThrough)
+        return 'no days of this segment were loaded';
+    const { configurationsLoaded, configurationsTotal } = outcome;
+    const isPartial = configurationsLoaded !== undefined &&
+        configurationsTotal !== undefined &&
+        configurationsLoaded < configurationsTotal;
+    const scope = isPartial
+        ? ` (${configurationsLoaded} of ${configurationsTotal} configurations)`
+        : '';
+    return `days through ${outcome.loadedThrough} were loaded${scope}`;
+}
+function describeUnloadedPeriod(meta, window) {
+    const isLastSegment = meta.segmentIndex >= meta.segmentsTotal;
+    const segments = isLastSegment
+        ? `segment ${meta.segmentIndex}`
+        : `segments ${meta.segmentIndex}–${meta.segmentsTotal}`;
+    return `${segments} (${window.startDate} – ${meta.requestedEnd}) ${isLastSegment ? 'was' : 'were'} not loaded`;
+}
+function buildSegmentMarker(meta, window, phase, at, outcome = {}) {
+    const period = `${meta.requestedStart} – ${meta.requestedEnd}`;
+    const position = `segment ${meta.segmentIndex} of ${meta.segmentsTotal} (${window.startDate} – ${window.endDate})`;
+    let message;
+    switch (phase) {
+        case 'started':
+            message = `Backfill ${period}: loading ${position}`;
+            break;
+        case 'completed':
+            message = `Backfill ${period}: ${position} completed — counted as 1 run`;
+            break;
+        case 'failed':
+            message =
+                outcome.chainEnd === 'stopped'
+                    ? `Backfill stopped: the project is restricted; ${describeUnloadedPeriod(meta, window)}.`
+                    : `Backfill ${period}: ${position} failed; ${describeLoadedDays(outcome)}${outcome.counted ? ' — counted as 1 run' : ''}`;
+            break;
+    }
+    return {
+        type: connector_message_type_enum_1.ConnectorMessageType.LOG,
+        at,
+        metric: exports.BACKFILL_SEGMENT_METRIC,
+        value: meta.segmentIndex,
+        tags: {
+            phase,
+            segmentStart: window.startDate,
+            segmentEnd: window.endDate,
+            backfillStart: meta.requestedStart,
+            backfillEnd: meta.requestedEnd,
+            segmentsTotal: meta.segmentsTotal,
+            ...(outcome.loadedThrough ? { loadedThrough: outcome.loadedThrough } : {}),
+            ...(outcome.chainContinues === undefined ? {} : { chainContinues: outcome.chainContinues }),
+            ...(outcome.chainEnd ? { chainEnd: outcome.chainEnd } : {}),
+        },
+        message,
+        toFormattedString: () => `[LOG] ${message}`,
+    };
+}
+async function createNextSegmentRun(runRepository, triggerService, previousRun, dataMart, meta, window) {
+    const additionalParams = (0, manual_backfill_range_1.nextSegmentAdditionalParams)(previousRun.additionalParams, meta, window);
+    const nextRun = await runRepository.save(runRepository.create({
+        dataMartId: previousRun.dataMartId,
+        type: data_mart_run_type_enum_1.DataMartRunType.CONNECTOR,
+        definitionRun: dataMart.definition,
+        status: data_mart_run_status_enum_1.DataMartRunStatus.PENDING,
+        createdById: previousRun.createdById ?? undefined,
+        runType: previousRun.runType,
+        logs: [],
+        errors: [],
+        additionalParams,
+    }));
+    await triggerService.createTrigger({
+        dataMartId: previousRun.dataMartId,
+        projectId: dataMart.projectId,
+        createdById: previousRun.createdById ?? 'system',
+        dataMartRunId: nextRun.id,
+        runType: previousRun.runType,
+        payload: additionalParams,
+    });
+    return nextRun;
+}
+//# sourceMappingURL=backfill-segment.js.map

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

@@ -9,5 +9,6 @@ export declare class ConnectorExecutionService {
     run(dataMart: DataMart, createdById: string, runType: RunType, payload?: Record<string, unknown>): Promise<string>;
     executeExistingRun(dataMart: DataMart, run: DataMartRun, payload?: Record<string, unknown> | null, signal?: AbortSignal): Promise<void>;
     executeInterruptedRuns(): Promise<void>;
+    repairBackfillChains(): Promise<void>;
     getDataMartConnectorRunsByStatus(status: DataMartRunStatus): Promise<DataMartRun[]>;
 }

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

@@ -26,6 +26,9 @@ let ConnectorExecutionService = class ConnectorExecutionService {
     async executeInterruptedRuns() {
         return this.connectorRunService.executeInterruptedRuns();
     }
+    async repairBackfillChains() {
+        return this.connectorRunService.repairBackfillChains();
+    }
     async getDataMartConnectorRunsByStatus(status) {
         return this.connectorRunService.getDataMartConnectorRunsByStatus(status);
     }

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

@@ -11,6 +11,7 @@ import { SystemTimeService } from '../../../common/scheduler/services/system-tim
 import { OwoxEventDispatcher } from '../../../common/event-dispatcher/owox-event-dispatcher';
 import { ProjectBillingService } from '../project-billing/project-billing.service';
 import { ConnectorDefinitionService } from './connector-definition.service';
+import { ConnectorRunTriggerService } from './connector-run-trigger.service';
 import { ConnectorProcessSpawnerService } from './connector-process-spawner.service';
 import { ConnectorStorageConfigService } from './connector-storage-config.service';
 import { ConnectorSourceConfigService } from './connector-source-config.service';
@@ -32,8 +33,9 @@ export declare class ConnectorExecutorService {
     private readonly connectorDefinitionService;
     private readonly connectorSourceCredentialsService;
     private readonly configService;
+    private readonly connectorRunTriggerService;
     private readonly logger;
-    constructor(dataMartRunRepository: Repository<DataMartRun>, processSpawner: ConnectorProcessSpawnerService, storageConfigService: ConnectorStorageConfigService, sourceConfigService: ConnectorSourceConfigService, credentialInjector: ConnectorCredentialInjectorService, connectorOutputCaptureService: ConnectorOutputCaptureService, connectorStateService: ConnectorStateService, gracefulShutdownService: GracefulShutdownService, systemTimeService: SystemTimeService, eventDispatcher: OwoxEventDispatcher, projectBillingService: ProjectBillingService, dataMartService: DataMartService, connectorDefinitionService: ConnectorDefinitionService, connectorSourceCredentialsService: ConnectorSourceCredentialsService, configService: ConfigService);
+    constructor(dataMartRunRepository: Repository<DataMartRun>, processSpawner: ConnectorProcessSpawnerService, storageConfigService: ConnectorStorageConfigService, sourceConfigService: ConnectorSourceConfigService, credentialInjector: ConnectorCredentialInjectorService, connectorOutputCaptureService: ConnectorOutputCaptureService, connectorStateService: ConnectorStateService, gracefulShutdownService: GracefulShutdownService, systemTimeService: SystemTimeService, eventDispatcher: OwoxEventDispatcher, projectBillingService: ProjectBillingService, dataMartService: DataMartService, connectorDefinitionService: ConnectorDefinitionService, connectorSourceCredentialsService: ConnectorSourceCredentialsService, configService: ConfigService, connectorRunTriggerService: ConnectorRunTriggerService);
     executeInBackground(dataMart: DataMart, run: DataMartRun, payload?: Record<string, unknown> | null, signal?: AbortSignal): Promise<void>;
     private actualizeSchemaAfterConnectorExecution;
     private runConnectorConfigurations;
@@ -49,6 +51,7 @@ export declare class ConnectorExecutorService {
     private stripManifestForRunner;
     private createRunLogFlusher;
     private updateRunStatus;
+    private writeRunOutcome;
     private mergeWithPersistedOutput;
     private discountFlushedEntries;
     private capMergedEntries;