@owox/backend 0.0.0 → 0.1.0

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

@@ -0,0 +1,190 @@
+"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 ConnectorExecutionService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectorExecutionService = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("@nestjs/typeorm");
+const typeorm_2 = require("typeorm");
+const connector_runner_1 = require("@owox/connector-runner");
+const data_mart_run_entity_1 = require("../entities/data-mart-run.entity");
+const data_mart_definition_type_enum_1 = require("../enums/data-mart-definition-type.enum");
+const data_mart_run_status_enum_1 = require("../enums/data-mart-run-status.enum");
+const data_storage_type_enum_1 = require("../data-storage-types/enums/data-storage-type.enum");
+let ConnectorExecutionService = ConnectorExecutionService_1 = class ConnectorExecutionService {
+    dataMartRunRepository;
+    logger = new common_1.Logger(ConnectorExecutionService_1.name);
+    constructor(dataMartRunRepository) {
+        this.dataMartRunRepository = dataMartRunRepository;
+    }
+    async run(dataMart) {
+        this.validateDataMartForConnector(dataMart);
+        const dataMartRun = await this.createDataMartRun(dataMart);
+        this.executeInBackground(dataMart, dataMartRun.id).catch(error => {
+            this.logger.error(`Background execution failed for run ${dataMartRun.id}:`, error);
+        });
+        return dataMartRun.id;
+    }
+    async getRunStatus(runId) {
+        return this.dataMartRunRepository.findOne({
+            where: { id: runId },
+            relations: ['dataMart'],
+        });
+    }
+    async getDataMartRuns(dataMartId) {
+        return this.dataMartRunRepository.find({
+            where: { dataMartId },
+            order: { createdAt: 'DESC' },
+        });
+    }
+    validateDataMartForConnector(dataMart) {
+        if (dataMart.definitionType !== data_mart_definition_type_enum_1.DataMartDefinitionType.CONNECTOR) {
+            throw new Error('DataMart is not a connector type');
+        }
+    }
+    async createDataMartRun(dataMart) {
+        const dataMartRun = this.dataMartRunRepository.create({
+            dataMartId: dataMart.id,
+            definitionRun: dataMart.definition,
+            status: data_mart_run_status_enum_1.DataMartRunStatus.RUNNING,
+            logs: [],
+            errors: [],
+        });
+        return this.dataMartRunRepository.save(dataMartRun);
+    }
+    createLogCaptureConfig(dataMartId, capturedErrors, capturedLogs) {
+        return {
+            logCapture: {
+                onStdout: (message) => {
+                    const logMessage = message.trim();
+                    capturedLogs.push(logMessage);
+                    this.logger.log(`[${dataMartId}]: ${logMessage}`);
+                },
+                onStderr: (message) => {
+                    const errorMessage = message.trim();
+                    capturedErrors.push(errorMessage);
+                    this.logger.error(`[${dataMartId}]: ${errorMessage}`);
+                },
+                passThrough: false,
+            },
+        };
+    }
+    async executeInBackground(dataMart, runId) {
+        const capturedLogs = [];
+        const capturedErrors = [];
+        const logCaptureConfig = this.createLogCaptureConfig(dataMart.id, capturedErrors, capturedLogs);
+        try {
+            await this.runConnectorConfigurations(runId, dataMart, logCaptureConfig);
+            await this.updateRunStatus(runId, capturedLogs, capturedErrors);
+        }
+        catch (error) {
+            await this.handleRunFailure(runId, error, capturedLogs, capturedErrors, dataMart.id);
+        }
+    }
+    async runConnectorConfigurations(runId, dataMart, logCaptureConfig) {
+        const definition = dataMart.definition;
+        const { connector } = definition;
+        for (const config of connector.source.configuration) {
+            const runConfig = new connector_runner_1.RunConfig({
+                name: connector.source.name,
+                datamartId: dataMart.id,
+                source: this.getSourceConfig(connector, config),
+                storage: this.getStorageConfig(dataMart),
+            });
+            const connectorRunner = new connector_runner_1.ConnectorRunner();
+            await connectorRunner.run(dataMart.id, runId, runConfig, logCaptureConfig);
+        }
+    }
+    async updateRunStatus(runId, capturedLogs, capturedErrors) {
+        const status = capturedErrors.length > 0 ? data_mart_run_status_enum_1.DataMartRunStatus.FAILED : data_mart_run_status_enum_1.DataMartRunStatus.SUCCESS;
+        await this.dataMartRunRepository.update(runId, {
+            status,
+            logs: capturedLogs,
+            errors: capturedErrors,
+        });
+    }
+    async handleRunFailure(runId, error, capturedLogs, capturedErrors, dataMartId) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        capturedErrors.push(errorMessage);
+        await this.dataMartRunRepository.update(runId, {
+            status: data_mart_run_status_enum_1.DataMartRunStatus.FAILED,
+            logs: capturedLogs,
+            errors: capturedErrors,
+        });
+        this.logger.error(`Connector execution failed for DataMart ${dataMartId}:`, error);
+    }
+    getSourceConfig(connector, config) {
+        const fieldsConfig = connector.source.fields
+            .map(field => `${connector.source.node} ${field}`)
+            .join(', ');
+        return new connector_runner_1.SourceConfig({
+            name: connector.source.name,
+            config: {
+                ...config,
+                Fields: fieldsConfig,
+            },
+        });
+    }
+    getStorageConfig(dataMart) {
+        const definition = dataMart.definition;
+        const { connector } = definition;
+        switch (dataMart.storage.type) {
+            case data_storage_type_enum_1.DataStorageType.GOOGLE_BIGQUERY:
+                return this.createBigQueryStorageConfig(dataMart, connector);
+            case data_storage_type_enum_1.DataStorageType.AWS_ATHENA:
+                return this.createAthenaStorageConfig(dataMart, connector);
+            default:
+                throw new Error(`Unsupported storage type: ${dataMart.storage.type}`);
+        }
+    }
+    createBigQueryStorageConfig(dataMart, connector) {
+        const storageConfig = dataMart.storage.config;
+        const datasetId = connector.storage?.fullyQualifiedName.split('.')[0];
+        return new connector_runner_1.StorageConfig({
+            name: data_storage_type_enum_1.DataStorageType.GOOGLE_BIGQUERY,
+            config: {
+                DestinationLocation: storageConfig?.location,
+                DestinationDatasetID: `${storageConfig.projectId}.${datasetId}`,
+                DestinationProjectID: storageConfig.projectId,
+                DestinationDatasetName: datasetId,
+                ProjectID: storageConfig.projectId,
+            },
+        });
+    }
+    createAthenaStorageConfig(dataMart, connector) {
+        const storageConfig = dataMart.storage.config;
+        const credentials = dataMart.storage.credentials;
+        return new connector_runner_1.StorageConfig({
+            name: data_storage_type_enum_1.DataStorageType.AWS_ATHENA,
+            config: {
+                AWSRegion: storageConfig.region,
+                AWSAccessKeyId: credentials.accessKeyId,
+                AWSSecretAccessKey: credentials.secretAccessKey,
+                S3BucketName: storageConfig.outputBucket,
+                S3Prefix: dataMart.id,
+                AthenaDatabaseName: connector.storage?.fullyQualifiedName.split('.')[0],
+                DestinationTableNamePrefix: '',
+                DestinationTableName: connector.storage?.fullyQualifiedName.split('.')[1],
+                AthenaOutputLocation: `s3://${storageConfig.outputBucket}/owox-data-marts/${dataMart.id}`,
+            },
+        });
+    }
+};
+exports.ConnectorExecutionService = ConnectorExecutionService;
+exports.ConnectorExecutionService = ConnectorExecutionService = ConnectorExecutionService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_1.InjectRepository)(data_mart_run_entity_1.DataMartRun)),
+    __metadata("design:paramtypes", [typeorm_2.Repository])
+], ConnectorExecutionService);
+//# sourceMappingURL=connector-execution.service.js.map

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

@@ -0,0 +1,79 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectorService = void 0;
+const common_1 = require("@nestjs/common");
+const connectors_1 = require("@owox/connectors");
+const connector_specification_1 = require("../connector-types/connector-specification");
+const connector_fields_schema_1 = require("../connector-types/connector-fields-schema");
+let ConnectorService = class ConnectorService {
+    async getAvailableConnectors() {
+        return connectors_1.AvailableConnectors.map(connector => ({
+            name: connector,
+            title: connector,
+            description: null,
+            icon: null,
+        }));
+    }
+    async getConnectorSpecification(connectorName) {
+        this.validateConnectorExists(connectorName);
+        const source = this.createConnectorSource(connectorName);
+        const configSchema = this.mapConfigToSchema(source.config);
+        return connector_specification_1.ConnectorSpecification.parse(configSchema);
+    }
+    async getConnectorFieldsSchema(connectorName) {
+        this.validateConnectorExists(connectorName);
+        const sourceInstance = this.createConnectorSource(connectorName);
+        const sourceFieldsSchema = sourceInstance.getFieldsSchema();
+        const fieldsSchema = this.mapFieldsSchemaToDto(sourceFieldsSchema);
+        return connector_fields_schema_1.ConnectorFieldsSchema.parse(fieldsSchema);
+    }
+    validateConnectorExists(connectorName) {
+        if (Object.keys(connectors_1.Connectors).length === 0) {
+            throw new Error('No connectors found');
+        }
+        if (!Object.keys(connectors_1.Connectors).includes(connectorName)) {
+            throw new Error(`Connector '${connectorName}' not found`);
+        }
+    }
+    createConnectorSource(connectorName) {
+        const source = connectors_1.Connectors[connectorName][`${connectorName}Source`];
+        return new source(new connectors_1.Core.AbstractConfig({}));
+    }
+    mapConfigToSchema(config) {
+        return Object.keys(config).map(key => ({
+            name: key,
+            title: config[key].displayName,
+            description: config[key].description,
+            default: config[key].default,
+            requiredType: config[key].requiredType,
+            required: config[key].isRequired,
+            options: config[key].options,
+            placeholder: config[key].placeholder,
+            showInUI: config[key].showInUI,
+        }));
+    }
+    mapFieldsSchemaToDto(sourceFieldsSchema) {
+        return Object.keys(sourceFieldsSchema).map(key => ({
+            name: key,
+            overview: sourceFieldsSchema[key].overview,
+            description: sourceFieldsSchema[key].description,
+            documentation: sourceFieldsSchema[key].documentation,
+            fields: Object.keys(sourceFieldsSchema[key].fields).map(fieldKey => ({
+                name: fieldKey,
+                type: sourceFieldsSchema[key].fields[fieldKey].type,
+                description: sourceFieldsSchema[key].fields[fieldKey].description,
+            })),
+        }));
+    }
+};
+exports.ConnectorService = ConnectorService;
+exports.ConnectorService = ConnectorService = __decorate([
+    (0, common_1.Injectable)()
+], ConnectorService);
+//# sourceMappingURL=connector.service.js.map

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

@@ -0,0 +1,39 @@
+"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); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataDestinationService = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("@nestjs/typeorm");
+const typeorm_2 = require("typeorm");
+const data_destination_entity_1 = require("../entities/data-destination.entity");
+let DataDestinationService = class DataDestinationService {
+    dataDestinationRepository;
+    constructor(dataDestinationRepository) {
+        this.dataDestinationRepository = dataDestinationRepository;
+    }
+    async getByIdAndProjectId(projectId, id) {
+        const entity = await this.dataDestinationRepository.findOne({ where: { id, projectId } });
+        if (!entity) {
+            throw new common_1.NotFoundException(`DataDestination with id ${id} and projectId ${projectId} not found`);
+        }
+        return entity;
+    }
+};
+exports.DataDestinationService = DataDestinationService;
+exports.DataDestinationService = DataDestinationService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_1.InjectRepository)(data_destination_entity_1.DataDestination)),
+    __metadata("design:paramtypes", [typeorm_2.Repository])
+], DataDestinationService);
+//# sourceMappingURL=data-destination.service.js.map

package/dist/src/data-marts/use-cases/connector/available-connector.service.js

@@ -0,0 +1,29 @@
+"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.AvailableConnectorService = void 0;
+const common_1 = require("@nestjs/common");
+const connector_service_1 = require("../../services/connector.service");
+let AvailableConnectorService = class AvailableConnectorService {
+    connectorService;
+    constructor(connectorService) {
+        this.connectorService = connectorService;
+    }
+    async run() {
+        return this.connectorService.getAvailableConnectors();
+    }
+};
+exports.AvailableConnectorService = AvailableConnectorService;
+exports.AvailableConnectorService = AvailableConnectorService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [connector_service_1.ConnectorService])
+], AvailableConnectorService);
+//# sourceMappingURL=available-connector.service.js.map

package/dist/src/data-marts/use-cases/connector/fields-connector.service.js

@@ -0,0 +1,29 @@
+"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.FieldsConnectorService = void 0;
+const common_1 = require("@nestjs/common");
+const connector_service_1 = require("../../services/connector.service");
+let FieldsConnectorService = class FieldsConnectorService {
+    connectorService;
+    constructor(connectorService) {
+        this.connectorService = connectorService;
+    }
+    async run(connectorName) {
+        return await this.connectorService.getConnectorFieldsSchema(connectorName);
+    }
+};
+exports.FieldsConnectorService = FieldsConnectorService;
+exports.FieldsConnectorService = FieldsConnectorService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [connector_service_1.ConnectorService])
+], FieldsConnectorService);
+//# sourceMappingURL=fields-connector.service.js.map

package/dist/src/data-marts/use-cases/connector/specification-connector.service.js

@@ -0,0 +1,29 @@
+"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.SpecificationConnectorService = void 0;
+const common_1 = require("@nestjs/common");
+const connector_service_1 = require("../../services/connector.service");
+let SpecificationConnectorService = class SpecificationConnectorService {
+    connectorService;
+    constructor(connectorService) {
+        this.connectorService = connectorService;
+    }
+    async run(connectorName) {
+        return this.connectorService.getConnectorSpecification(connectorName);
+    }
+};
+exports.SpecificationConnectorService = SpecificationConnectorService;
+exports.SpecificationConnectorService = SpecificationConnectorService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [connector_service_1.ConnectorService])
+], SpecificationConnectorService);
+//# sourceMappingURL=specification-connector.service.js.map

package/dist/src/data-marts/use-cases/create-data-destination.service.js

@@ -0,0 +1,51 @@
+"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); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateDataDestinationService = void 0;
+const typeorm_1 = require("typeorm");
+const data_destination_entity_1 = require("../entities/data-destination.entity");
+const typeorm_2 = require("@nestjs/typeorm");
+const common_1 = require("@nestjs/common");
+const data_destination_mapper_1 = require("../mappers/data-destination.mapper");
+const data_destination_credentials_validator_facade_1 = require("../data-destination-types/facades/data-destination-credentials-validator.facade");
+let CreateDataDestinationService = class CreateDataDestinationService {
+    repository;
+    mapper;
+    credentialsValidator;
+    constructor(repository, mapper, credentialsValidator) {
+        this.repository = repository;
+        this.mapper = mapper;
+        this.credentialsValidator = credentialsValidator;
+    }
+    async run(command) {
+        await this.credentialsValidator.checkCredentials(command.type, command.credentials);
+        const entity = this.repository.create({
+            title: command.title,
+            type: command.type,
+            projectId: command.projectId,
+            credentials: command.credentials,
+        });
+        const savedEntity = await this.repository.save(entity);
+        return this.mapper.toDomainDto(savedEntity);
+    }
+};
+exports.CreateDataDestinationService = CreateDataDestinationService;
+exports.CreateDataDestinationService = CreateDataDestinationService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_2.InjectRepository)(data_destination_entity_1.DataDestination)),
+    __metadata("design:paramtypes", [typeorm_1.Repository,
+        data_destination_mapper_1.DataDestinationMapper,
+        data_destination_credentials_validator_facade_1.DataDestinationCredentialsValidatorFacade])
+], CreateDataDestinationService);
+//# sourceMappingURL=create-data-destination.service.js.map

package/dist/src/data-marts/use-cases/create-report.service.js

@@ -0,0 +1,83 @@
+"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); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateReportService = void 0;
+const typeorm_1 = require("typeorm");
+const common_1 = require("@nestjs/common");
+const typeorm_2 = require("@nestjs/typeorm");
+const report_entity_1 = require("../entities/report.entity");
+const data_mart_entity_1 = require("../entities/data-mart.entity");
+const data_destination_entity_1 = require("../entities/data-destination.entity");
+const report_mapper_1 = require("../mappers/report.mapper");
+const data_mart_status_enum_1 = require("../enums/data-mart-status.enum");
+const data_destination_access_validator_facade_1 = require("../data-destination-types/facades/data-destination-access-validator.facade");
+let CreateReportService = class CreateReportService {
+    reportRepository;
+    dataMartRepository;
+    dataDestinationRepository;
+    dataDestinationAccessValidationFacade;
+    mapper;
+    constructor(reportRepository, dataMartRepository, dataDestinationRepository, dataDestinationAccessValidationFacade, mapper) {
+        this.reportRepository = reportRepository;
+        this.dataMartRepository = dataMartRepository;
+        this.dataDestinationRepository = dataDestinationRepository;
+        this.dataDestinationAccessValidationFacade = dataDestinationAccessValidationFacade;
+        this.mapper = mapper;
+    }
+    async run(command) {
+        const dataMart = await this.dataMartRepository.findOne({
+            where: {
+                id: command.dataMartId,
+                projectId: command.projectId,
+            },
+        });
+        if (!dataMart) {
+            throw new common_1.BadRequestException(`Data mart with ID ${command.dataMartId} not found`);
+        }
+        if (dataMart.status !== data_mart_status_enum_1.DataMartStatus.PUBLISHED) {
+            throw new common_1.BadRequestException(`Cannot create report for data mart with status ${dataMart.status}. Data mart must be in PUBLISHED status.`);
+        }
+        const dataDestination = await this.dataDestinationRepository.findOne({
+            where: {
+                id: command.dataDestinationId,
+                projectId: command.projectId,
+            },
+        });
+        if (!dataDestination) {
+            throw new common_1.BadRequestException(`Data destination with ID ${command.dataDestinationId} not found`);
+        }
+        await this.dataDestinationAccessValidationFacade.checkAccess(dataDestination.type, command.destinationConfig, dataDestination);
+        const report = this.reportRepository.create({
+            title: command.title,
+            dataMart,
+            dataDestination,
+            destinationConfig: command.destinationConfig,
+        });
+        const newReport = await this.reportRepository.save(report);
+        return this.mapper.toDomainDto(newReport);
+    }
+};
+exports.CreateReportService = CreateReportService;
+exports.CreateReportService = CreateReportService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_2.InjectRepository)(report_entity_1.Report)),
+    __param(1, (0, typeorm_2.InjectRepository)(data_mart_entity_1.DataMart)),
+    __param(2, (0, typeorm_2.InjectRepository)(data_destination_entity_1.DataDestination)),
+    __metadata("design:paramtypes", [typeorm_1.Repository,
+        typeorm_1.Repository,
+        typeorm_1.Repository,
+        data_destination_access_validator_facade_1.DataDestinationAccessValidatorFacade,
+        report_mapper_1.ReportMapper])
+], CreateReportService);
+//# sourceMappingURL=create-report.service.js.map

package/dist/src/data-marts/use-cases/delete-data-destination.service.js

@@ -0,0 +1,59 @@
+"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); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeleteDataDestinationService = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("@nestjs/typeorm");
+const typeorm_2 = require("typeorm");
+const data_destination_entity_1 = require("../entities/data-destination.entity");
+const report_entity_1 = require("../entities/report.entity");
+const data_destination_service_1 = require("../services/data-destination.service");
+const business_violation_exception_1 = require("../../common/exceptions/business-violation.exception");
+let DeleteDataDestinationService = class DeleteDataDestinationService {
+    dataDestinationRepository;
+    reportRepository;
+    dataDestinationService;
+    constructor(dataDestinationRepository, reportRepository, dataDestinationService) {
+        this.dataDestinationRepository = dataDestinationRepository;
+        this.reportRepository = reportRepository;
+        this.dataDestinationService = dataDestinationService;
+    }
+    async run(command) {
+        const destination = await this.dataDestinationService.getByIdAndProjectId(command.projectId, command.id);
+        const reportsCount = await this.reportRepository.count({
+            where: {
+                dataDestination: {
+                    id: destination.id,
+                },
+            },
+        });
+        if (reportsCount > 0) {
+            throw new business_violation_exception_1.BusinessViolationException(`Cannot delete the destination because it is referenced by ${reportsCount} existing report(s).`);
+        }
+        await this.dataDestinationRepository.softDelete({
+            id: command.id,
+            projectId: command.projectId,
+        });
+    }
+};
+exports.DeleteDataDestinationService = DeleteDataDestinationService;
+exports.DeleteDataDestinationService = DeleteDataDestinationService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_1.InjectRepository)(data_destination_entity_1.DataDestination)),
+    __param(1, (0, typeorm_1.InjectRepository)(report_entity_1.Report)),
+    __metadata("design:paramtypes", [typeorm_2.Repository,
+        typeorm_2.Repository,
+        data_destination_service_1.DataDestinationService])
+], DeleteDataDestinationService);
+//# sourceMappingURL=delete-data-destination.service.js.map

package/dist/src/data-marts/use-cases/delete-report.service.js

@@ -0,0 +1,46 @@
+"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); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeleteReportService = void 0;
+const typeorm_1 = require("typeorm");
+const common_1 = require("@nestjs/common");
+const typeorm_2 = require("@nestjs/typeorm");
+const report_entity_1 = require("../entities/report.entity");
+let DeleteReportService = class DeleteReportService {
+    reportRepository;
+    constructor(reportRepository) {
+        this.reportRepository = reportRepository;
+    }
+    async run(command) {
+        const report = await this.reportRepository.findOne({
+            where: {
+                id: command.id,
+                dataMart: {
+                    projectId: command.projectId,
+                },
+            },
+        });
+        if (!report) {
+            throw new common_1.NotFoundException(`Report with ID ${command.id} not found`);
+        }
+        await this.reportRepository.remove(report);
+    }
+};
+exports.DeleteReportService = DeleteReportService;
+exports.DeleteReportService = DeleteReportService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_2.InjectRepository)(report_entity_1.Report)),
+    __metadata("design:paramtypes", [typeorm_1.Repository])
+], DeleteReportService);
+//# sourceMappingURL=delete-report.service.js.map