@owox/backend 0.0.0 → 0.1.0

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

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AthenaApiAdapter = void 0;
+const common_1 = require("@nestjs/common");
+const client_athena_1 = require("@aws-sdk/client-athena");
+class AthenaApiAdapter {
+    logger = new common_1.Logger(AthenaApiAdapter.name);
+    athenaClient;
+    constructor(credentials, config) {
+        this.athenaClient = new client_athena_1.AthenaClient({
+            region: config.region,
+            credentials: {
+                accessKeyId: credentials.accessKeyId,
+                secretAccessKey: credentials.secretAccessKey,
+                sessionToken: credentials.sessionToken,
+            },
+        });
+    }
+    async executeQuery(query, databaseName, outputBucket, outputPrefix) {
+        const startQueryCommand = new client_athena_1.StartQueryExecutionCommand({
+            QueryString: query,
+            QueryExecutionContext: {
+                Database: databaseName,
+            },
+            ResultConfiguration: {
+                OutputLocation: `s3://${outputBucket}/${outputPrefix}`,
+            },
+        });
+        const response = await this.athenaClient.send(startQueryCommand);
+        const queryExecutionId = response.QueryExecutionId;
+        if (!queryExecutionId) {
+            throw new Error('Failed to start query execution');
+        }
+        return { queryExecutionId };
+    }
+    async waitForQueryToComplete(queryExecutionId) {
+        if (!queryExecutionId) {
+            throw new Error('No query execution ID');
+        }
+        const getQueryExecutionCommand = new client_athena_1.GetQueryExecutionCommand({
+            QueryExecutionId: queryExecutionId,
+        });
+        let status;
+        do {
+            await new Promise(resolve => setTimeout(resolve, 1000));
+            const response = await this.athenaClient.send(getQueryExecutionCommand);
+            status = response.QueryExecution?.Status?.State;
+            this.logger.debug(`Query status: ${status}`);
+            if (status === client_athena_1.QueryExecutionState.FAILED) {
+                const errorMessage = response.QueryExecution?.Status?.StateChangeReason || 'Unknown error';
+                throw new Error(`Query execution failed: ${errorMessage}`);
+            }
+            if (status === client_athena_1.QueryExecutionState.CANCELLED) {
+                throw new Error('Query execution was cancelled');
+            }
+        } while (status !== client_athena_1.QueryExecutionState.SUCCEEDED);
+    }
+    async getQueryResultsMetadata(queryExecutionId) {
+        if (!queryExecutionId) {
+            throw new Error('No query execution ID');
+        }
+        const resultsCommand = new client_athena_1.GetQueryResultsCommand({
+            QueryExecutionId: queryExecutionId,
+            MaxResults: 1,
+        });
+        const results = await this.athenaClient.send(resultsCommand);
+        if (!results.ResultSet ||
+            !results.ResultSet.ResultSetMetadata ||
+            !results.ResultSet.ResultSetMetadata.ColumnInfo) {
+            throw new Error('Failed to get query results metadata');
+        }
+        return results.ResultSet.ResultSetMetadata;
+    }
+    async getQueryResults(queryExecutionId, batchId, maxResults = 1000) {
+        if (!queryExecutionId) {
+            throw new Error('No query execution ID');
+        }
+        const resultsCommand = new client_athena_1.GetQueryResultsCommand({
+            QueryExecutionId: queryExecutionId,
+            MaxResults: maxResults,
+            NextToken: batchId,
+        });
+        const results = await this.athenaClient.send(resultsCommand);
+        if (!results.ResultSet || !results.ResultSet.Rows) {
+            throw new Error('Failed to get query results');
+        }
+        return results;
+    }
+}
+exports.AthenaApiAdapter = AthenaApiAdapter;
+//# sourceMappingURL=athena-api.adapter.js.map

package/dist/src/data-marts/data-storage-types/athena/adapters/s3-api-adapter.factory.js

@@ -0,0 +1,21 @@
+"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.S3ApiAdapterFactory = void 0;
+const common_1 = require("@nestjs/common");
+const s3_api_adapter_1 = require("./s3-api.adapter");
+let S3ApiAdapterFactory = class S3ApiAdapterFactory {
+    create(credentials, config) {
+        return new s3_api_adapter_1.S3ApiAdapter(credentials, config);
+    }
+};
+exports.S3ApiAdapterFactory = S3ApiAdapterFactory;
+exports.S3ApiAdapterFactory = S3ApiAdapterFactory = __decorate([
+    (0, common_1.Injectable)()
+], S3ApiAdapterFactory);
+//# sourceMappingURL=s3-api-adapter.factory.js.map

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

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.S3ApiAdapter = void 0;
+const common_1 = require("@nestjs/common");
+const client_s3_1 = require("@aws-sdk/client-s3");
+class S3ApiAdapter {
+    logger = new common_1.Logger(S3ApiAdapter.name);
+    s3Client;
+    constructor(credentials, config) {
+        this.s3Client = new client_s3_1.S3Client({
+            region: config.region,
+            credentials: {
+                accessKeyId: credentials.accessKeyId,
+                secretAccessKey: credentials.secretAccessKey,
+                sessionToken: credentials.sessionToken,
+            },
+        });
+    }
+    async cleanupOutputFiles(outputBucket, outputPrefix) {
+        if (!outputBucket || !outputPrefix) {
+            this.logger.debug('No output location to clean up');
+            return;
+        }
+        try {
+            const listCommand = new client_s3_1.ListObjectsV2Command({
+                Bucket: outputBucket,
+                Prefix: outputPrefix,
+            });
+            const listedObjects = await this.s3Client.send(listCommand);
+            if (!listedObjects.Contents || listedObjects.Contents.length === 0) {
+                this.logger.debug('No objects to delete');
+                return;
+            }
+            for (const object of listedObjects.Contents) {
+                if (!object.Key)
+                    continue;
+                const deleteCommand = new client_s3_1.DeleteObjectCommand({
+                    Bucket: outputBucket,
+                    Key: object.Key,
+                });
+                await this.s3Client.send(deleteCommand);
+                this.logger.debug(`Deleted object: ${object.Key}`);
+            }
+            this.logger.debug('Successfully cleaned up query results');
+        }
+        catch (error) {
+            this.logger.error('Error cleaning up query results', error);
+            throw error;
+        }
+    }
+}
+exports.S3ApiAdapter = S3ApiAdapter;
+//# sourceMappingURL=s3-api.adapter.js.map

package/dist/src/data-marts/data-storage-types/athena/services/athena-report-reader.service.js

@@ -0,0 +1,158 @@
+"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 AthenaReportReader_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AthenaReportReader = void 0;
+const common_1 = require("@nestjs/common");
+const data_storage_type_enum_1 = require("../../enums/data-storage-type.enum");
+const report_data_description_dto_1 = require("../../../dto/domain/report-data-description.dto");
+const report_data_batch_dto_1 = require("../../../dto/domain/report-data-batch.dto");
+const data_mart_definition_guards_1 = require("../../../dto/schemas/data-mart-table-definitions/data-mart-definition.guards");
+const athena_api_adapter_factory_1 = require("../adapters/athena-api-adapter.factory");
+const s3_api_adapter_factory_1 = require("../adapters/s3-api-adapter.factory");
+const data_storage_credentials_guards_1 = require("../../data-storage-credentials.guards");
+const data_storage_config_guards_1 = require("../../data-storage-config.guards");
+let AthenaReportReader = AthenaReportReader_1 = class AthenaReportReader {
+    athenaAdapterFactory;
+    s3AdapterFactory;
+    logger = new common_1.Logger(AthenaReportReader_1.name);
+    type = data_storage_type_enum_1.DataStorageType.AWS_ATHENA;
+    athenaAdapter;
+    s3Adapter;
+    queryExecutionId;
+    outputBucket;
+    outputPrefix;
+    databaseName;
+    constructor(athenaAdapterFactory, s3AdapterFactory) {
+        this.athenaAdapterFactory = athenaAdapterFactory;
+        this.s3AdapterFactory = s3AdapterFactory;
+    }
+    async prepareReportData(report) {
+        const { storage, definition } = report.dataMart;
+        if (!storage || !definition) {
+            throw new Error('Data Mart is not properly configured');
+        }
+        await this.prepareApiAdapters(storage);
+        await this.prepareQueryExecution(definition);
+        if (!this.queryExecutionId) {
+            throw new Error('Query execution ID not set');
+        }
+        await this.athenaAdapter.waitForQueryToComplete(this.queryExecutionId);
+        const metadata = await this.athenaAdapter.getQueryResultsMetadata(this.queryExecutionId);
+        if (!metadata.ColumnInfo) {
+            throw new Error('Failed to get query results metadata');
+        }
+        const dataHeaders = metadata.ColumnInfo.map(col => col.Name || '');
+        return new report_data_description_dto_1.ReportDataDescription(dataHeaders);
+    }
+    async readReportDataBatch(batchId, maxDataRows = 1000) {
+        if (!this.athenaAdapter) {
+            throw new Error('Report data must be prepared before read');
+        }
+        if (!this.queryExecutionId) {
+            throw new Error('Query execution ID not set');
+        }
+        const results = await this.athenaAdapter.getQueryResults(this.queryExecutionId, batchId, maxDataRows);
+        if (!results.ResultSet || !results.ResultSet.Rows) {
+            throw new Error('Failed to get query results');
+        }
+        const startIndex = !batchId ? 1 : 0;
+        const rows = results.ResultSet.Rows.slice(startIndex);
+        const mappedRows = rows.map(row => {
+            if (!row.Data)
+                return [];
+            return row.Data.map(cell => cell.VarCharValue);
+        });
+        return new report_data_batch_dto_1.ReportDataBatch(mappedRows, results.NextToken);
+    }
+    async finalize() {
+        this.logger.debug('Finalizing report read');
+        if (!this.s3Adapter) {
+            this.logger.debug('No S3 adapter to clean up');
+            return;
+        }
+        if (!this.outputBucket || !this.outputPrefix) {
+            this.logger.debug('No output location to clean up');
+            return;
+        }
+        try {
+            await this.s3Adapter.cleanupOutputFiles(this.outputBucket, this.outputPrefix);
+        }
+        catch (error) {
+            this.logger.error('Error cleaning up query results', error);
+            throw error;
+        }
+    }
+    async prepareApiAdapters(storage) {
+        try {
+            if (!(0, data_storage_credentials_guards_1.isAthenaCredentials)(storage.credentials)) {
+                throw new Error('Athena credentials are not properly configured');
+            }
+            if (!(0, data_storage_config_guards_1.isAthenaConfig)(storage.config)) {
+                throw new Error('Athena config is not properly configured');
+            }
+            this.athenaAdapter = this.athenaAdapterFactory.create(storage.credentials, storage.config);
+            this.s3Adapter = this.s3AdapterFactory.create(storage.credentials, storage.config);
+            this.outputBucket = storage.config.outputBucket;
+            this.databaseName = storage.config.databaseName;
+            this.logger.debug('Athena and S3 adapters created successfully');
+        }
+        catch (error) {
+            this.logger.error('Failed to create adapters', error);
+            throw error;
+        }
+    }
+    async prepareQueryExecution(dataMartDefinition) {
+        this.logger.debug('Preparing query execution', dataMartDefinition);
+        try {
+            if ((0, data_mart_definition_guards_1.isTableDefinition)(dataMartDefinition)) {
+                await this.prepareTableData(dataMartDefinition);
+            }
+            else if ((0, data_mart_definition_guards_1.isSqlDefinition)(dataMartDefinition)) {
+                await this.prepareSqlData(dataMartDefinition);
+            }
+            else if ((0, data_mart_definition_guards_1.isViewDefinition)(dataMartDefinition)) {
+                await this.prepareViewData(dataMartDefinition);
+            }
+            else if ((0, data_mart_definition_guards_1.isTablePatternDefinition)(dataMartDefinition)) {
+                throw new Error('Table pattern queries are not supported in Athena');
+            }
+            else {
+                throw new Error('Invalid data mart definition');
+            }
+        }
+        catch (error) {
+            this.logger.error('Failed to prepare query execution', error);
+            throw error;
+        }
+    }
+    async prepareSqlData(dataMartDefinition) {
+        await this.executeQuery(dataMartDefinition.sqlQuery);
+    }
+    async prepareViewData(dataMartDefinition) {
+        await this.executeQuery(`SELECT * FROM ${dataMartDefinition.fullyQualifiedName}`);
+    }
+    async prepareTableData(dataMartDefinition) {
+        await this.executeQuery(`SELECT * FROM ${dataMartDefinition.fullyQualifiedName}`);
+    }
+    async executeQuery(query) {
+        this.outputPrefix = `owox-data-marts/${Date.now()}-${Math.random().toString(36).substring(2, 15)}`;
+        const result = await this.athenaAdapter.executeQuery(query, this.databaseName, this.outputBucket, this.outputPrefix);
+        this.queryExecutionId = result.queryExecutionId;
+    }
+};
+exports.AthenaReportReader = AthenaReportReader;
+exports.AthenaReportReader = AthenaReportReader = AthenaReportReader_1 = __decorate([
+    (0, common_1.Injectable)({ scope: common_1.Scope.TRANSIENT }),
+    __metadata("design:paramtypes", [athena_api_adapter_factory_1.AthenaApiAdapterFactory,
+        s3_api_adapter_factory_1.S3ApiAdapterFactory])
+], AthenaReportReader);
+//# sourceMappingURL=athena-report-reader.service.js.map

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

@@ -0,0 +1,21 @@
+"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.BigQueryApiAdapterFactory = void 0;
+const common_1 = require("@nestjs/common");
+const bigquery_api_adapter_1 = require("./bigquery-api.adapter");
+let BigQueryApiAdapterFactory = class BigQueryApiAdapterFactory {
+    create(credentials, config) {
+        return new bigquery_api_adapter_1.BigQueryApiAdapter(credentials, config);
+    }
+};
+exports.BigQueryApiAdapterFactory = BigQueryApiAdapterFactory;
+exports.BigQueryApiAdapterFactory = BigQueryApiAdapterFactory = __decorate([
+    (0, common_1.Injectable)()
+], BigQueryApiAdapterFactory);
+//# sourceMappingURL=bigquery-api-adapter.factory.js.map

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BigQueryApiAdapter = void 0;
+const bigquery_1 = require("@google-cloud/bigquery");
+class BigQueryApiAdapter {
+    bigQuery;
+    constructor(credentials, config) {
+        this.bigQuery = new bigquery_1.BigQuery({
+            projectId: config.projectId,
+            location: config.location,
+            credentials: credentials,
+            scopes: [
+                'https://www.googleapis.com/auth/bigquery',
+                'https://www.googleapis.com/auth/drive.readonly',
+            ],
+        });
+    }
+    async executeQuery(query) {
+        const [, , res] = await this.bigQuery.query(query, { maxResults: 0 });
+        if (!res || !res.jobReference || !res.jobReference.jobId) {
+            throw new Error('Unexpected error during getting sql result job id');
+        }
+        return { jobId: res.jobReference.jobId };
+    }
+    async getJob(jobId) {
+        const job = this.bigQuery.job(jobId);
+        const [jobResult] = await job.get();
+        return jobResult;
+    }
+    createTableReference(projectId, datasetId, tableId) {
+        const dataset = this.bigQuery.dataset(datasetId, { projectId: projectId });
+        return dataset.table(tableId);
+    }
+}
+exports.BigQueryApiAdapter = BigQueryApiAdapter;
+//# sourceMappingURL=bigquery-api.adapter.js.map

package/dist/src/data-marts/data-storage-types/bigquery/schemas/bigquery-credentials.schema.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BigQueryCredentialsSchema = void 0;
+const google_service_account_key_schema_1 = require("../../../../common/schemas/google-service-account-key.schema");
+exports.BigQueryCredentialsSchema = google_service_account_key_schema_1.GoogleServiceAccountKeySchema.extend({});
+//# sourceMappingURL=bigquery-credentials.schema.js.map

package/dist/src/data-marts/data-storage-types/bigquery/services/bigquery-report-reader.service.js

@@ -0,0 +1,132 @@
+"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 BigQueryReportReader_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BigQueryReportReader = void 0;
+const report_data_description_dto_1 = require("../../../dto/domain/report-data-description.dto");
+const report_data_batch_dto_1 = require("../../../dto/domain/report-data-batch.dto");
+const data_storage_type_enum_1 = require("../../enums/data-storage-type.enum");
+const common_1 = require("@nestjs/common");
+const data_mart_definition_guards_1 = require("../../../dto/schemas/data-mart-table-definitions/data-mart-definition.guards");
+const bigquery_api_adapter_factory_1 = require("../adapters/bigquery-api-adapter.factory");
+const data_storage_credentials_guards_1 = require("../../data-storage-credentials.guards");
+const data_storage_config_guards_1 = require("../../data-storage-config.guards");
+let BigQueryReportReader = BigQueryReportReader_1 = class BigQueryReportReader {
+    adapterFactory;
+    logger = new common_1.Logger(BigQueryReportReader_1.name);
+    type = data_storage_type_enum_1.DataStorageType.GOOGLE_BIGQUERY;
+    adapter;
+    reportResultTable;
+    dataHeaders;
+    constructor(adapterFactory) {
+        this.adapterFactory = adapterFactory;
+    }
+    async prepareReportData(report) {
+        const { storage, definition } = report.dataMart;
+        if (!storage || !definition) {
+            throw new Error('Data Mart is not properly configured');
+        }
+        await this.prepareBigQuery(storage);
+        await this.prepareReportResultTable(definition);
+        const [metaData] = await this.reportResultTable.getMetadata();
+        if (!metaData.numRows || !metaData.schema || !metaData.schema.fields) {
+            throw new Error('Failed to get table metadata');
+        }
+        this.dataHeaders = metaData.schema.fields.map(f => f.name);
+        return new report_data_description_dto_1.ReportDataDescription(this.dataHeaders, parseInt(metaData.numRows));
+    }
+    async readReportDataBatch(batchId, maxRows = 10000) {
+        if (!this.adapter || !this.reportResultTable) {
+            throw new Error('Report data must be prepared before read');
+        }
+        const [rows, nextBatch] = await this.reportResultTable.getRows({
+            pageToken: batchId,
+            maxResults: maxRows,
+            autoPaginate: false,
+        });
+        const mappedRows = rows.map(r => this.dataHeaders.map(h => r[h].value ?? r[h]));
+        return new report_data_batch_dto_1.ReportDataBatch(mappedRows, nextBatch?.pageToken);
+    }
+    async finalize() {
+        this.logger.debug('Finalizing report read');
+    }
+    async prepareReportResultTable(dataMartDefinition) {
+        this.logger.debug('Preparing report result table', dataMartDefinition);
+        try {
+            if ((0, data_mart_definition_guards_1.isTableDefinition)(dataMartDefinition)) {
+                await this.prepareTableData(dataMartDefinition);
+            }
+            else if ((0, data_mart_definition_guards_1.isSqlDefinition)(dataMartDefinition)) {
+                await this.prepareSqlData(dataMartDefinition);
+            }
+            else if ((0, data_mart_definition_guards_1.isViewDefinition)(dataMartDefinition)) {
+                await this.prepareViewData(dataMartDefinition);
+            }
+            else if ((0, data_mart_definition_guards_1.isTablePatternDefinition)(dataMartDefinition)) {
+                await this.prepareTablePatternData(dataMartDefinition);
+            }
+            else {
+                throw new Error('Invalid data mart definition');
+            }
+        }
+        catch (error) {
+            this.logger.error('Failed to prepare report data', error);
+            throw error;
+        }
+    }
+    async prepareSqlData(dataMartDefinition) {
+        await this.prepareQueryData(dataMartDefinition.sqlQuery);
+    }
+    async prepareViewData(dataMartDefinition) {
+        await this.prepareQueryData(`SELECT * FROM \`${dataMartDefinition.fullyQualifiedName}\``);
+    }
+    async prepareTablePatternData(dataMartDefinition) {
+        await this.prepareQueryData(`SELECT * FROM \`${dataMartDefinition.pattern}*\``);
+    }
+    async prepareQueryData(query) {
+        const { jobId } = await this.adapter.executeQuery(query);
+        const jobResult = await this.adapter.getJob(jobId);
+        const destinationTable = jobResult.metadata.configuration.query.destinationTable;
+        this.defineReportResultTable(destinationTable.projectId, destinationTable.datasetId, destinationTable.tableId);
+    }
+    async prepareTableData(dataMartDefinition) {
+        const tableRef = dataMartDefinition.fullyQualifiedName.split('.');
+        this.defineReportResultTable(tableRef[0], tableRef[1], tableRef[2]);
+    }
+    defineReportResultTable(projectId, datasetId, tableId) {
+        this.reportResultTable = this.adapter.createTableReference(projectId, datasetId, tableId);
+        if (!this.reportResultTable) {
+            throw new Error('Report result table not set');
+        }
+    }
+    async prepareBigQuery(dataStorage) {
+        try {
+            if (!(0, data_storage_credentials_guards_1.isBigqueryCredentials)(dataStorage.credentials)) {
+                throw new Error('Google BigQuery credentials are not properly configured');
+            }
+            if (!(0, data_storage_config_guards_1.isBigQueryConfig)(dataStorage.config)) {
+                throw new Error('Google BigQuery config is not properly configured');
+            }
+            this.adapter = this.adapterFactory.create(dataStorage.credentials, dataStorage.config);
+            this.logger.debug('BigQuery adapter created successfully');
+        }
+        catch (error) {
+            this.logger.error('Failed to create BigQuery adapter', error);
+            throw error;
+        }
+    }
+};
+exports.BigQueryReportReader = BigQueryReportReader;
+exports.BigQueryReportReader = BigQueryReportReader = BigQueryReportReader_1 = __decorate([
+    (0, common_1.Injectable)({ scope: common_1.Scope.TRANSIENT }),
+    __metadata("design:paramtypes", [bigquery_api_adapter_factory_1.BigQueryApiAdapterFactory])
+], BigQueryReportReader);
+//# sourceMappingURL=bigquery-report-reader.service.js.map

package/dist/src/data-marts/data-storage-types/data-storage-config.guards.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBigQueryConfig = isBigQueryConfig;
+exports.isAthenaConfig = isAthenaConfig;
+const bigquery_config_schema_1 = require("./bigquery/schemas/bigquery-config.schema");
+const athena_config_schema_1 = require("./athena/schemas/athena-config.schema");
+function isBigQueryConfig(config) {
+    return bigquery_config_schema_1.BigQueryConfigSchema.safeParse(config).success;
+}
+function isAthenaConfig(config) {
+    return athena_config_schema_1.AthenaConfigSchema.safeParse(config).success;
+}
+//# sourceMappingURL=data-storage-config.guards.js.map

package/dist/src/data-marts/data-storage-types/data-storage-credentials.guards.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBigqueryCredentials = isBigqueryCredentials;
+exports.isAthenaCredentials = isAthenaCredentials;
+const bigquery_credentials_schema_1 = require("./bigquery/schemas/bigquery-credentials.schema");
+const athena_credentials_schema_1 = require("./athena/schemas/athena-credentials.schema");
+function isBigqueryCredentials(credentials) {
+    return bigquery_credentials_schema_1.BigQueryCredentialsSchema.safeParse(credentials).success;
+}
+function isAthenaCredentials(credentials) {
+    return athena_credentials_schema_1.AthenaCredentialsSchema.safeParse(credentials).success;
+}
+//# sourceMappingURL=data-storage-credentials.guards.js.map

package/dist/src/data-marts/data-storage-types/data-storage-credentials.type.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data-storage-credentials.type.js.map

package/dist/src/data-marts/data-storage-types/data-storage-facades.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dataStorageFacadesProviders = void 0;
+const data_storage_access_facade_1 = require("./facades/data-storage-access.facade");
+exports.dataStorageFacadesProviders = [data_storage_access_facade_1.DataStorageAccessFacade];
+//# sourceMappingURL=data-storage-facades.js.map

package/dist/src/data-marts/data-storage-types/data-storage-providers.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dataStorageResolverProviders = exports.DATA_STORAGE_REPORT_READER_RESOLVER = exports.DATA_STORAGE_ACCESS_VALIDATOR_RESOLVER = void 0;
+const bigquery_access_validator_1 = require("./bigquery/services/bigquery-access.validator");
+const athena_access_validator_1 = require("./athena/services/athena-access.validator");
+const type_resolver_1 = require("../../common/resolver/type-resolver");
+const bigquery_report_reader_service_1 = require("./bigquery/services/bigquery-report-reader.service");
+const athena_report_reader_service_1 = require("./athena/services/athena-report-reader.service");
+const bigquery_api_adapter_factory_1 = require("./bigquery/adapters/bigquery-api-adapter.factory");
+const athena_api_adapter_factory_1 = require("./athena/adapters/athena-api-adapter.factory");
+const s3_api_adapter_factory_1 = require("./athena/adapters/s3-api-adapter.factory");
+exports.DATA_STORAGE_ACCESS_VALIDATOR_RESOLVER = Symbol('DATA_STORAGE_ACCESS_VALIDATOR_RESOLVER');
+exports.DATA_STORAGE_REPORT_READER_RESOLVER = Symbol('DATA_STORAGE_REPORT_READER_RESOLVER');
+const accessValidatorProviders = [bigquery_access_validator_1.BigQueryAccessValidator, athena_access_validator_1.AthenaAccessValidator];
+const storageDataProviders = [bigquery_report_reader_service_1.BigQueryReportReader, athena_report_reader_service_1.AthenaReportReader];
+const adapterFactories = [bigquery_api_adapter_factory_1.BigQueryApiAdapterFactory, athena_api_adapter_factory_1.AthenaApiAdapterFactory, s3_api_adapter_factory_1.S3ApiAdapterFactory];
+exports.dataStorageResolverProviders = [
+    ...accessValidatorProviders,
+    ...storageDataProviders,
+    ...adapterFactories,
+    {
+        provide: exports.DATA_STORAGE_ACCESS_VALIDATOR_RESOLVER,
+        useFactory: (...validators) => new type_resolver_1.TypeResolver(validators),
+        inject: accessValidatorProviders,
+    },
+    {
+        provide: exports.DATA_STORAGE_REPORT_READER_RESOLVER,
+        useFactory: (...storageDataProviders) => new type_resolver_1.TypeResolver(storageDataProviders),
+        inject: storageDataProviders,
+    },
+];
+//# sourceMappingURL=data-storage-providers.js.map

package/dist/src/data-marts/data-storage-types/interfaces/data-storage-report-reader.interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data-storage-report-reader.interface.js.map

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateDataDestinationCommand = void 0;
+class CreateDataDestinationCommand {
+    projectId;
+    title;
+    type;
+    credentials;
+    constructor(projectId, title, type, credentials) {
+        this.projectId = projectId;
+        this.title = title;
+        this.type = type;
+        this.credentials = credentials;
+    }
+}
+exports.CreateDataDestinationCommand = CreateDataDestinationCommand;
+//# sourceMappingURL=create-data-destination.command.js.map

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateReportCommand = void 0;
+class CreateReportCommand {
+    projectId;
+    userId;
+    title;
+    dataMartId;
+    dataDestinationId;
+    destinationConfig;
+    constructor(projectId, userId, title, dataMartId, dataDestinationId, destinationConfig) {
+        this.projectId = projectId;
+        this.userId = userId;
+        this.title = title;
+        this.dataMartId = dataMartId;
+        this.dataDestinationId = dataDestinationId;
+        this.destinationConfig = destinationConfig;
+    }
+}
+exports.CreateReportCommand = CreateReportCommand;
+//# sourceMappingURL=create-report.command.js.map