@owox/backend 0.35.0 → 0.36.0

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

@@ -0,0 +1,491 @@
+"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 __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var ConnectorDefinitionService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectorDefinitionService = void 0;
+const common_1 = require("@nestjs/common");
+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 business_violation_exception_1 = require("../../../common/exceptions/business-violation.exception");
+const query_error_utils_1 = require("../../../common/typeorm/query-error.utils");
+const custom_connector_dto_1 = require("../../dto/presentation/custom-connector.dto");
+const data_mart_definition_type_enum_1 = require("../../enums/data-mart-definition-type.enum");
+const connector_definition_entity_1 = require("../../entities/connector-definition.entity");
+const connector_definition_version_entity_1 = require("../../entities/connector-definition-version.entity");
+const access_decision_1 = require("../access-decision");
+const data_mart_service_1 = require("../data-mart.service");
+const declarative_manifest_schemas_1 = require("./declarative-manifest-schemas");
+const NAME_PATTERN = /^[A-Za-z][A-Za-z0-9_]*$/;
+const MAX_NAME_LENGTH = 255;
+function tombstonedName(name, id) {
+    const prefix = `deleted:${id}:`;
+    return prefix + name.slice(0, MAX_NAME_LENGTH - prefix.length);
+}
+function blankToNull(value) {
+    return typeof value === 'string' && value.trim() !== '' ? value : null;
+}
+const RESERVED_NAMES = new Set((connectors_1.AvailableConnectors ?? []).map(name => name.toLowerCase()));
+const BUNDLED_NAMES = new Set(connectors_1.AvailableConnectors ?? []);
+const SAVE_DRAFT_ATTEMPTS = 3;
+const ACTIVE_VERSION_NUMBER_COLUMNS = ['id', 'version'];
+const VERSION_SUMMARY_COLUMNS = [
+    'id',
+    'version',
+    'status',
+    'publishedAt',
+];
+let ConnectorDefinitionService = ConnectorDefinitionService_1 = class ConnectorDefinitionService {
+    definitionRepo;
+    versionRepo;
+    dataMartService;
+    accessDecisionService;
+    logger = new common_1.Logger(ConnectorDefinitionService_1.name);
+    constructor(definitionRepo, versionRepo, dataMartService, accessDecisionService) {
+        this.definitionRepo = definitionRepo;
+        this.versionRepo = versionRepo;
+        this.dataMartService = dataMartService;
+        this.accessDecisionService = accessDecisionService;
+    }
+    async create(projectId, userId, input) {
+        this.assertManifestFitsSpawn(input.manifest);
+        await this.assertNameAvailable(projectId, input.name);
+        let definition;
+        try {
+            definition = await this.definitionRepo.save(this.definitionRepo.create({
+                projectId,
+                name: input.name,
+                title: input.title,
+                description: blankToNull(input.description),
+                logo: blankToNull(input.logo),
+                docUrl: blankToNull(input.docUrl),
+                createdById: userId,
+            }));
+        }
+        catch (e) {
+            if (!(0, query_error_utils_1.isUniqueConstraintViolation)(e)) {
+                throw e;
+            }
+            throw new common_1.ConflictException(`A custom connector named '${input.name}' was just created in this project by another request`);
+        }
+        await this.versionRepo.save(this.versionRepo.create({
+            connectorDefinitionId: definition.id,
+            version: 1,
+            manifest: input.manifest,
+            status: connector_definition_version_entity_1.ConnectorDefinitionVersionStatus.DRAFT,
+            createdById: userId,
+        }));
+        return definition;
+    }
+    async listByProject(projectId) {
+        return this.definitionRepo.find({ where: { projectId } });
+    }
+    async getById(projectId, id) {
+        const def = await this.definitionRepo.findOne({ where: { id, projectId } });
+        if (!def) {
+            throw new common_1.NotFoundException(`Custom connector '${id}' not found`);
+        }
+        return def;
+    }
+    async updateMetadata(projectId, id, patch) {
+        await this.getById(projectId, id);
+        const columns = {};
+        if (patch.title !== undefined) {
+            columns.title = patch.title;
+        }
+        if (patch.description !== undefined) {
+            columns.description = patch.description;
+        }
+        if (patch.logo !== undefined) {
+            columns.logo = patch.logo;
+        }
+        if (patch.docUrl !== undefined) {
+            columns.docUrl = patch.docUrl;
+        }
+        if (Object.keys(columns).length > 0) {
+            await this.definitionRepo.update({ id, projectId }, columns);
+        }
+        return this.getById(projectId, id);
+    }
+    async listVersions(projectId, id) {
+        await this.getById(projectId, id);
+        return this.versionRepo.find({
+            where: { connectorDefinitionId: id },
+            order: { version: 'ASC' },
+            select: VERSION_SUMMARY_COLUMNS,
+        });
+    }
+    async getVersion(projectId, id, version) {
+        await this.getById(projectId, id);
+        const row = await this.versionRepo.findOne({
+            where: { connectorDefinitionId: id, version },
+        });
+        if (!row) {
+            throw new common_1.NotFoundException(`Version ${version} of connector '${id}' not found`);
+        }
+        return row;
+    }
+    async resolveManifest(projectId, name, version) {
+        const def = await this.definitionRepo.findOne({ where: { projectId, name } });
+        if (!def) {
+            throw new common_1.NotFoundException(`Custom connector '${name}' not found`);
+        }
+        const row = version !== undefined
+            ? await this.versionRepo.findOne({
+                where: {
+                    connectorDefinitionId: def.id,
+                    version,
+                    status: connector_definition_version_entity_1.ConnectorDefinitionVersionStatus.PUBLISHED,
+                },
+            })
+            : await this.resolveActivePublished(def);
+        if (!row) {
+            throw new common_1.NotFoundException(`No published ${version !== undefined ? `version ${version}` : 'version'} for connector '${name}'`);
+        }
+        return row.manifest;
+    }
+    async tryResolveManifest(projectId, name, version) {
+        if (BUNDLED_NAMES.has(name)) {
+            return null;
+        }
+        const def = await this.definitionRepo.findOne({ where: { projectId, name } });
+        if (!def) {
+            return null;
+        }
+        const row = version !== undefined
+            ? await this.versionRepo.findOne({
+                where: {
+                    connectorDefinitionId: def.id,
+                    version,
+                    status: connector_definition_version_entity_1.ConnectorDefinitionVersionStatus.PUBLISHED,
+                },
+            })
+            : def.activeVersionId
+                ? await this.versionRepo.findOne({
+                    where: {
+                        id: def.activeVersionId,
+                        status: connector_definition_version_entity_1.ConnectorDefinitionVersionStatus.PUBLISHED,
+                    },
+                })
+                : null;
+        if (!row) {
+            throw new common_1.BadRequestException(`Custom connector '${name}' has no published version${version !== undefined ? ` ${version}` : ''} to run`);
+        }
+        return row.manifest;
+    }
+    async saveDraft(projectId, id, manifest) {
+        this.assertManifestFitsSpawn(manifest);
+        await this.getById(projectId, id);
+        for (let attempt = 0; attempt < SAVE_DRAFT_ATTEMPTS; attempt++) {
+            const latest = await this.versionRepo.findOne({
+                where: { connectorDefinitionId: id },
+                order: { version: 'DESC' },
+            });
+            if (latest && latest.status === connector_definition_version_entity_1.ConnectorDefinitionVersionStatus.DRAFT) {
+                const result = await this.versionRepo.update({ id: latest.id, status: connector_definition_version_entity_1.ConnectorDefinitionVersionStatus.DRAFT }, { manifest });
+                if (result.affected) {
+                    latest.manifest = manifest;
+                    return latest;
+                }
+                const current = await this.versionRepo.findOne({ where: { id: latest.id } });
+                if (current?.status === connector_definition_version_entity_1.ConnectorDefinitionVersionStatus.DRAFT) {
+                    return current;
+                }
+                continue;
+            }
+            try {
+                return await this.versionRepo.save(this.versionRepo.create({
+                    connectorDefinitionId: id,
+                    version: (latest?.version ?? 0) + 1,
+                    manifest,
+                    status: connector_definition_version_entity_1.ConnectorDefinitionVersionStatus.DRAFT,
+                }));
+            }
+            catch (e) {
+                if (!(0, query_error_utils_1.isUniqueConstraintViolation)(e)) {
+                    throw e;
+                }
+            }
+        }
+        throw new common_1.ConflictException(`Connector '${id}' is being changed by another request. Reload it and save again.`);
+    }
+    async publish(projectId, id, actor) {
+        const def = await this.getById(projectId, id);
+        await this.assertMayChangeActiveVersion(def, actor, 'Publishing', 'publish');
+        const draft = await this.versionRepo.findOne({
+            where: { connectorDefinitionId: id, status: connector_definition_version_entity_1.ConnectorDefinitionVersionStatus.DRAFT },
+            order: { version: 'DESC' },
+            ...(this.canLockRows() ? { lock: { mode: 'pessimistic_write' } } : {}),
+        });
+        if (!draft) {
+            throw new common_1.BadRequestException(`Connector '${id}' has no draft to publish`);
+        }
+        let model;
+        try {
+            model = new connectors_1.Core.ManifestParser().parse(JSON.stringify(draft.manifest));
+        }
+        catch (e) {
+            throw new common_1.BadRequestException(`Invalid connector manifest: ${e.message}`);
+        }
+        this.assertNodesHavePrimaryKeys(draft.manifest);
+        (0, declarative_manifest_schemas_1.specificationFromManifest)(draft.manifest);
+        (0, declarative_manifest_schemas_1.fieldsSchemaFromManifest)(draft.manifest);
+        const displayFields = this.displayFieldsOf(draft.manifest);
+        const warnings = this.reportSecretCoverage(def.name, draft.version, model);
+        const publishedAt = new Date();
+        const flipped = await this.versionRepo.update({ id: draft.id, status: connector_definition_version_entity_1.ConnectorDefinitionVersionStatus.DRAFT }, { status: connector_definition_version_entity_1.ConnectorDefinitionVersionStatus.PUBLISHED, publishedAt });
+        if (!flipped.affected) {
+            throw new common_1.ConflictException(`Connector '${id}' was published by another request. Reload it to see the result.`);
+        }
+        await this.definitionRepo.update({ id, projectId }, { ...displayFields, activeVersionId: draft.id });
+        const published = { ...draft, status: connector_definition_version_entity_1.ConnectorDefinitionVersionStatus.PUBLISHED, publishedAt };
+        return { version: published, warnings };
+    }
+    canLockRows() {
+        return ['mysql', 'mariadb'].includes(String(this.versionRepo.manager?.connection?.options?.type));
+    }
+    assertNodesHavePrimaryKeys(manifest) {
+        const nodes = (manifest.nodes ?? {});
+        const problems = Object.entries(nodes)
+            .filter(([, node]) => !Array.isArray(node?.uniqueKeys) || node.uniqueKeys.length === 0)
+            .map(([name]) => `Node "${name}" has no primary key. Mark the fields that identify a row as its primary key.`);
+        if (problems.length > 0) {
+            throw new common_1.BadRequestException(problems.join(' '));
+        }
+    }
+    async setActiveVersion(projectId, id, version, actor) {
+        const def = await this.getById(projectId, id);
+        await this.assertMayChangeActiveVersion(def, actor, 'Activating this version', 'activate it');
+        const row = await this.versionRepo.findOne({
+            where: {
+                connectorDefinitionId: id,
+                version,
+                status: connector_definition_version_entity_1.ConnectorDefinitionVersionStatus.PUBLISHED,
+            },
+        });
+        if (!row) {
+            throw new common_1.BadRequestException(`Connector '${id}' has no published version ${version} to activate`);
+        }
+        await this.definitionRepo.update({ id, projectId }, { ...this.displayFieldsOf(row.manifest), activeVersionId: row.id });
+        return this.getById(projectId, id);
+    }
+    displayFieldsOf(manifest) {
+        const fields = {};
+        if (typeof manifest.title === 'string' && manifest.title.trim() !== '') {
+            fields.title = manifest.title;
+        }
+        for (const key of ['description', 'docUrl']) {
+            if (key in manifest) {
+                const value = manifest[key];
+                fields[key] = typeof value === 'string' && value.trim() !== '' ? value : null;
+            }
+        }
+        const tooLong = [
+            typeof fields.title === 'string' && fields.title.length > custom_connector_dto_1.MAX_VARCHAR_LENGTH && 'title',
+            typeof fields.docUrl === 'string' && fields.docUrl.length > custom_connector_dto_1.MAX_VARCHAR_LENGTH && 'docUrl',
+            typeof fields.description === 'string' &&
+                Buffer.byteLength(fields.description) > custom_connector_dto_1.MAX_TEXT_COLUMN_BYTES &&
+                'description',
+        ].filter(Boolean);
+        if (tooLong.length > 0) {
+            throw new common_1.BadRequestException(`The manifest's ${tooLong.join(', ')} is too long: a title or docs link holds ` +
+                `${custom_connector_dto_1.MAX_VARCHAR_LENGTH} characters, a description ${custom_connector_dto_1.MAX_TEXT_COLUMN_BYTES} bytes.`);
+        }
+        return fields;
+    }
+    async assertMayChangeActiveVersion(def, actor, change, adminAction) {
+        const name = def.name.toLowerCase();
+        const connectorMarts = await this.dataMartService.findByProjectIdAndDefinitionType(def.projectId, data_mart_definition_type_enum_1.DataMartDefinitionType.CONNECTOR);
+        const followers = connectorMarts.filter(mart => {
+            const source = mart.definition?.connector?.source;
+            return source?.name?.toLowerCase() === name && typeof source.version !== 'number';
+        });
+        if (followers.length === 0)
+            return;
+        const ask = (ids, action) => this.accessDecisionService.canAccessMany(actor.userId, actor.roles, access_decision_1.EntityType.DATA_MART, ids, action, def.projectId);
+        const canEdit = await ask(followers.map(mart => mart.id), access_decision_1.Action.EDIT);
+        const denied = followers.filter(mart => !canEdit.get(mart.id));
+        if (denied.length === 0)
+            return;
+        const canSee = await ask(denied.map(mart => mart.id), access_decision_1.Action.SEE);
+        const named = denied.filter(mart => canSee.get(mart.id)).map(mart => `"${mart.title}"`);
+        const unseen = denied.length - named.length;
+        const listed = unseen > 0 ? [...named, `${unseen} you cannot see`] : named;
+        throw new common_1.ForbiddenException(`${change} would change what runs in Data Marts you cannot edit (${listed.join(', ')}). ` +
+            `Ask a project admin to ${adminAction}, or ask for edit access to those Data Marts.`);
+    }
+    async getActiveVersionNumberForDef(def) {
+        if (!def.activeVersionId)
+            return null;
+        const row = await this.versionRepo.findOne({
+            where: { id: def.activeVersionId },
+            select: ACTIVE_VERSION_NUMBER_COLUMNS,
+        });
+        return row ? row.version : null;
+    }
+    async getActiveVersionNumbersByDefId(defs) {
+        const activeVersionIds = defs
+            .map(def => def.activeVersionId)
+            .filter((id) => Boolean(id));
+        if (activeVersionIds.length === 0) {
+            return new Map();
+        }
+        const rows = await this.versionRepo.find({
+            where: { id: (0, typeorm_2.In)(activeVersionIds) },
+            select: ACTIVE_VERSION_NUMBER_COLUMNS,
+        });
+        const versionNumberById = new Map(rows.map(row => [row.id, row.version]));
+        const byDefId = new Map();
+        for (const def of defs) {
+            const version = def.activeVersionId ? versionNumberById.get(def.activeVersionId) : undefined;
+            if (version !== undefined) {
+                byDefId.set(def.id, version);
+            }
+        }
+        return byDefId;
+    }
+    async softDelete(projectId, id) {
+        const def = await this.getById(projectId, id);
+        const connectorMarts = await this.dataMartService.findByProjectIdAndDefinitionType(projectId, data_mart_definition_type_enum_1.DataMartDefinitionType.CONNECTOR);
+        const name = def.name.toLowerCase();
+        const referencedDataMarts = connectorMarts
+            .filter(mart => {
+            const definition = mart.definition;
+            return definition?.connector?.source?.name?.toLowerCase() === name;
+        })
+            .map(mart => mart.id);
+        if (referencedDataMarts.length > 0) {
+            throw new business_violation_exception_1.BusinessViolationException('Cannot delete the connector because it is referenced by existing data marts.', { referencedDataMarts });
+        }
+        await this.definitionRepo.update({ id }, { name: tombstonedName(def.name, id) });
+        await this.definitionRepo.softDelete(id);
+    }
+    reportSecretCoverage(connectorName, version, model) {
+        const prefix = `Connector '${connectorName}' v${version}:`;
+        const autoMarked = model.autoSecretAuthParameters ?? [];
+        if (autoMarked.length > 0) {
+            this.logger.log(`${prefix} marked ${autoMarked.join(', ')} as SECRET — ` +
+                `used by "authentication" but not declared secret in the manifest. ` +
+                `These values are stored separately and masked in API responses.`);
+        }
+        const warnings = [];
+        const undeclared = model.undeclaredAuthParameters ?? [];
+        if (undeclared.length > 0) {
+            warnings.push(`${prefix} "authentication" references undeclared ` +
+                `parameter(s) ${undeclared.join(', ')}. They cannot be marked SECRET, so any value ` +
+                `supplied under those names stays in plain text in the Data Mart definition. ` +
+                `Declare them in "parameters" to have them protected.`);
+        }
+        for (const entry of model.unprotectedRequestParameters ?? []) {
+            const where = entry.usedIn?.length ? ` at ${entry.usedIn.join(', ')}` : '';
+            warnings.push(`${prefix} parameter '${entry.parameter}' looks like a ` +
+                `credential and is interpolated into a node request${where}, but is not marked SECRET. ` +
+                `Its value stays in plain text in the Data Mart definition and is returned to anyone ` +
+                `who can read the Data Mart. Add "attributes": ["SECRET"] to the parameter if it is a ` +
+                `credential.`);
+        }
+        for (const parameter of this.collectSecretsCarryingValues(model.parameters)) {
+            warnings.push(`${prefix} parameter '${parameter}' is SECRET and declares a ` +
+                `default, placeholder or options list. Those are values for a credential field, and ` +
+                `the configuration specification — which every project member can read — ` +
+                `withholds them, so they will not reach the configuration form. Remove them, or drop the "SECRET" attribute if the value is not ` +
+                `a credential.`);
+        }
+        for (const warning of warnings) {
+            this.logger.warn(warning);
+        }
+        return warnings;
+    }
+    collectSecretsCarryingValues(parameters, prefix = '') {
+        if (!parameters || typeof parameters !== 'object' || Array.isArray(parameters))
+            return [];
+        const found = [];
+        for (const [name, raw] of Object.entries(parameters)) {
+            if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+                continue;
+            const field = raw;
+            const attributes = Array.isArray(field.attributes) ? field.attributes : [];
+            const carriesValue = ['default', 'placeholder', 'options'].some(key => field[key] !== undefined);
+            if (attributes.includes(connectors_1.Core.CONFIG_ATTRIBUTES.SECRET) && carriesValue) {
+                found.push(`${prefix}${name}`);
+            }
+            for (const branch of Array.isArray(field.oneOf) ? field.oneOf : []) {
+                const option = branch;
+                found.push(...this.collectSecretsCarryingValues(option.items, `${prefix}${name}.${option.value}.`));
+            }
+        }
+        return found;
+    }
+    assertManifestFitsSpawn(manifest) {
+        const sizeBytes = Buffer.byteLength(JSON.stringify(manifest), 'utf8');
+        if (sizeBytes > custom_connector_dto_1.MAX_MANIFEST_SIZE_BYTES) {
+            throw new common_1.BadRequestException(`Connector manifest is ${sizeBytes} bytes, over the ${custom_connector_dto_1.MAX_MANIFEST_SIZE_BYTES}-byte limit. ` +
+                `A larger manifest cannot be passed to the connector runner, so it would fail on every run.`);
+        }
+    }
+    async resolveActivePublished(def) {
+        if (!def.activeVersionId)
+            return null;
+        return this.versionRepo.findOne({
+            where: { id: def.activeVersionId, status: connector_definition_version_entity_1.ConnectorDefinitionVersionStatus.PUBLISHED },
+        });
+    }
+    async assertNameAvailable(projectId, name) {
+        if (!NAME_PATTERN.test(name)) {
+            throw new common_1.BadRequestException(`Connector name '${name}' is invalid: must start with a letter and contain only letters, digits, or underscores`);
+        }
+        const normalized = name.toLowerCase();
+        if (RESERVED_NAMES.has(normalized)) {
+            throw new common_1.BadRequestException(`Connector name '${name}' is reserved by a built-in connector`);
+        }
+        const namesInProject = await this.definitionRepo.find({
+            where: { projectId },
+            withDeleted: true,
+            select: ['id', 'name'],
+        });
+        if (namesInProject.some(existing => existing.name.toLowerCase() === normalized)) {
+            throw new common_1.BadRequestException(`A custom connector named '${name}' already exists in this project`);
+        }
+    }
+};
+exports.ConnectorDefinitionService = ConnectorDefinitionService;
+__decorate([
+    (0, typeorm_transactional_1.Transactional)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, Object]),
+    __metadata("design:returntype", Promise)
+], ConnectorDefinitionService.prototype, "create", null);
+__decorate([
+    (0, typeorm_transactional_1.Transactional)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, Object]),
+    __metadata("design:returntype", Promise)
+], ConnectorDefinitionService.prototype, "publish", null);
+__decorate([
+    (0, typeorm_transactional_1.Transactional)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String]),
+    __metadata("design:returntype", Promise)
+], ConnectorDefinitionService.prototype, "softDelete", null);
+exports.ConnectorDefinitionService = ConnectorDefinitionService = ConnectorDefinitionService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_1.InjectRepository)(connector_definition_entity_1.ConnectorDefinition)),
+    __param(1, (0, typeorm_1.InjectRepository)(connector_definition_version_entity_1.ConnectorDefinitionVersion)),
+    __metadata("design:paramtypes", [typeorm_2.Repository,
+        typeorm_2.Repository,
+        data_mart_service_1.DataMartService,
+        access_decision_1.AccessDecisionService])
+], ConnectorDefinitionService);
+//# sourceMappingURL=connector-definition.service.js.map

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

@@ -1,4 +1,6 @@
+import { ConfigService } from '@nestjs/config';
 import { Repository } from 'typeorm';
+export declare const MAX_MERGED_RUN_OUTPUT_ENTRIES = 10000;
 import { DataMart } from '../../entities/data-mart.entity';
 import { DataMartRun } from '../../entities/data-mart-run.entity';
 import { ConnectorOutputCaptureService } from '../../connector-types/connector-message/services/connector-output-capture.service';
@@ -8,6 +10,7 @@ import { GracefulShutdownService } from '../../../common/scheduler/services/grac
 import { SystemTimeService } from '../../../common/scheduler/services/system-time.service';
 import { OwoxEventDispatcher } from '../../../common/event-dispatcher/owox-event-dispatcher';
 import { ProjectBillingService } from '../project-billing/project-billing.service';
+import { ConnectorDefinitionService } from './connector-definition.service';
 import { ConnectorProcessSpawnerService } from './connector-process-spawner.service';
 import { ConnectorStorageConfigService } from './connector-storage-config.service';
 import { ConnectorSourceConfigService } from './connector-source-config.service';
@@ -26,9 +29,11 @@ export declare class ConnectorExecutorService {
     private readonly eventDispatcher;
     private readonly projectBillingService;
     private readonly dataMartService;
+    private readonly connectorDefinitionService;
     private readonly connectorSourceCredentialsService;
+    private readonly configService;
     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, connectorSourceCredentialsService: ConnectorSourceCredentialsService);
+    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);
     executeInBackground(dataMart: DataMart, run: DataMartRun, payload?: Record<string, unknown> | null, signal?: AbortSignal): Promise<void>;
     private actualizeSchemaAfterConnectorExecution;
     private runConnectorConfigurations;
@@ -41,7 +46,10 @@ export declare class ConnectorExecutorService {
     private findSourceCredentialId;
     private persistBackfillProgress;
     private isSuccessfulConnectorStatus;
+    private stripManifestForRunner;
+    private createRunLogFlusher;
     private updateRunStatus;
     private mergeWithPersistedOutput;
+    private discountFlushedEntries;
     private capMergedEntries;
 }