@owox/backend 0.35.0 → 0.36.0

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

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunLogFlusher = void 0;
+exports.createRunLogSnapshotReader = createRunLogSnapshotReader;
+function createRunLogSnapshotReader(logs, errors) {
+    const serializedLogs = [];
+    const serializedErrors = [];
+    const extend = (cache, buffer) => {
+        for (let i = cache.length; i < buffer.length; i++) {
+            cache.push(JSON.stringify(buffer[i]));
+        }
+        return cache.slice();
+    };
+    return () => ({
+        logs: extend(serializedLogs, logs),
+        errors: extend(serializedErrors, errors),
+    });
+}
+class RunLogFlusher {
+    intervalMs;
+    getSnapshot;
+    write;
+    onError;
+    timer = null;
+    lastCount = -1;
+    inFlight = Promise.resolve();
+    persisted = null;
+    constructor(intervalMs, getSnapshot, write, onError) {
+        this.intervalMs = intervalMs;
+        this.getSnapshot = getSnapshot;
+        this.write = write;
+        this.onError = onError;
+    }
+    start() {
+        if (this.intervalMs <= 0 || this.timer !== null)
+            return;
+        this.timer = setInterval(() => {
+            this.inFlight = this.inFlight.then(() => this.flushIfDirty());
+        }, this.intervalMs);
+    }
+    async flushIfDirty() {
+        const snapshot = this.getSnapshot();
+        const count = snapshot.logs.length + snapshot.errors.length;
+        if (count === 0 || count === this.lastCount)
+            return;
+        try {
+            await this.write(snapshot);
+            this.lastCount = count;
+            this.persisted = snapshot;
+        }
+        catch (error) {
+            this.onError?.(error);
+        }
+    }
+    persistedSnapshot() {
+        return this.persisted;
+    }
+    async stop() {
+        if (this.timer !== null) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+        await this.inFlight;
+    }
+}
+exports.RunLogFlusher = RunLogFlusher;
+//# sourceMappingURL=run-log-flusher.js.map

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

@@ -88,6 +88,7 @@ let DataMartService = DataMartService_1 = class DataMartService {
             'dm.title',
             'dm.status',
             'dm.description',
+            'dm.icon',
             'dm.definitionType',
             'dm.createdById',
             'dm.createdAt',
@@ -183,6 +184,7 @@ let DataMartService = DataMartService_1 = class DataMartService {
             'dm.title',
             'dm.status',
             'dm.description',
+            'dm.icon',
             'dm.schema',
             'dm.dataLastUpdated',
         ])

package/dist/src/data-marts/services/report-sql-composer.service.js

@@ -36,6 +36,20 @@ const field_aggregation_governance_1 = require("../dto/schemas/field-aggregation
 const aggregation_labels_1 = require("../dto/schemas/aggregation-labels");
 const field_type_category_1 = require("../dto/schemas/field-type-category");
 const report_data_header_dto_1 = require("../dto/domain/report-data-header.dto");
+function withMetricsShownForDryRun(dataMart, metricNames) {
+    const fields = dataMart.schema?.fields ?? [];
+    const isHiddenMetric = (field) => field.isHiddenForReporting === true &&
+        (0, calculated_field_utils_1.isCalculatedField)(field) &&
+        metricNames.includes(field.name);
+    if (!fields.some(isHiddenMetric))
+        return dataMart;
+    return Object.assign(Object.create(Object.getPrototypeOf(dataMart)), dataMart, {
+        schema: {
+            ...dataMart.schema,
+            fields: fields.map(field => isHiddenMetric(field) ? { ...field, isHiddenForReporting: false } : field),
+        },
+    });
+}
 let ReportSqlComposerService = class ReportSqlComposerService {
     blendedReportDataService;
     queryBuilderFacade;
@@ -348,7 +362,7 @@ let ReportSqlComposerService = class ReportSqlComposerService {
     }
     async composeMetricsOnly(dataMart, metricNames, accessor, precomputedBlendableSchema, tableReferences) {
         const plan = {
-            dataMart,
+            dataMart: withMetricsShownForDryRun(dataMart, metricNames),
             columnConfig: metricNames,
         };
         const joinedMetrics = (0, calculated_field_utils_1.calculatedFieldsOf)(dataMart.schema?.fields ?? []).filter(f => metricNames.includes(f.name) && (0, formula_live_reference_1.hasLiveJoinedReference)(f.calculated.formula));

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

@@ -28,5 +28,6 @@ export declare class ReportService {
     updateReportWithVersionControl(report: Report): Promise<void>;
     deleteReport(report: Report): Promise<void>;
     countByDataMartIdAndProjectId(dataMartId: string, projectId: string): Promise<number>;
+    countByDataMartIds(dataMartIds: string[]): Promise<Map<string, number>>;
     deleteAllByDataMartIdAndProjectId(dataMartId: string, projectId: string): Promise<void>;
 }

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

@@ -198,6 +198,19 @@ let ReportService = class ReportService {
             },
         });
     }
+    async countByDataMartIds(dataMartIds) {
+        if (dataMartIds.length === 0)
+            return new Map();
+        const rows = await this.repository
+            .createQueryBuilder('r')
+            .leftJoin('r.dataMart', 'dm')
+            .where('dm.id IN (:...ids)', { ids: dataMartIds })
+            .select('dm.id', 'dataMartId')
+            .addSelect('COUNT(*)', 'count')
+            .groupBy('dm.id')
+            .getRawMany();
+        return new Map(rows.map(row => [row.dataMartId, Number(row.count)]));
+    }
     async deleteAllByDataMartIdAndProjectId(dataMartId, projectId) {
         const reports = await this.repository.find({
             where: {

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

@@ -16,6 +16,7 @@ export declare class ScheduledTriggerService {
     constructor(triggerRepository: Repository<DataMartScheduledTrigger>);
     getByIdAndDataMartIdAndProjectId(id: string, dataMartId: string, projectId: string): Promise<DataMartScheduledTrigger>;
     getByIdAndProjectId(id: string, projectId: string): Promise<DataMartScheduledTrigger>;
+    countByDataMartIds(dataMartIds: string[]): Promise<Map<string, number>>;
     getAllByDataMartIdAndProjectId(dataMartId: string, projectId: string): Promise<DataMartScheduledTrigger[]>;
     listVisibleByProject(options: ListVisibleProjectScheduledTriggersOptions): Promise<DataMartScheduledTrigger[]>;
     deleteAllByDataMartIdAndProjectId(dataMartId: string, projectId: string): Promise<void>;

package/dist/src/data-marts/services/scheduled-trigger.service.js

@@ -50,6 +50,19 @@ let ScheduledTriggerService = class ScheduledTriggerService {
         }
         return trigger;
     }
+    async countByDataMartIds(dataMartIds) {
+        if (dataMartIds.length === 0)
+            return new Map();
+        const rows = await this.triggerRepository
+            .createQueryBuilder('t')
+            .leftJoin('t.dataMart', 'dm')
+            .where('dm.id IN (:...ids)', { ids: dataMartIds })
+            .select('dm.id', 'dataMartId')
+            .addSelect('COUNT(*)', 'count')
+            .groupBy('dm.id')
+            .getRawMany();
+        return new Map(rows.map(row => [row.dataMartId, Number(row.count)]));
+    }
     async getAllByDataMartIdAndProjectId(dataMartId, projectId) {
         return this.triggerRepository.find({
             where: {

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

@@ -76,6 +76,7 @@ let CreateDataMartService = CreateDataMartService_1 = class CreateDataMartServic
         }
         const dataMart = this.dataMartService.create({
             title: command.title,
+            icon: command.icon,
             projectId: command.projectId,
             createdById: command.userId,
             storage: dataStorage,

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

@@ -37,6 +37,7 @@ const access_decision_1 = require("../services/access-decision");
 const output_controls_validator_service_1 = require("../services/output-controls-validator.service");
 const report_access_service_1 = require("../services/report-access.service");
 const unique_count_sources_1 = require("../dto/schemas/unique-count-sources");
+const auto_aggregation_opt_out_schema_1 = require("../dto/schemas/auto-aggregation-opt-out.schema");
 const advanced_search_index_sync_service_1 = require("../services/advanced-search-index-sync.service");
 const search_facade_1 = require("../../common/search/search.facade");
 const looker_studio_report_service_1 = require("../services/looker-studio-report.service");
@@ -118,6 +119,7 @@ let CreateReportService = class CreateReportService {
             aggregationConfig: command.aggregationConfig ?? null,
             dateTruncConfig: command.dateTruncConfig ?? null,
             uniqueCountConfig: (0, unique_count_sources_1.foldEmptyUniqueCountConfig)(command.uniqueCountConfig),
+            autoAggregationOptOut: (0, auto_aggregation_opt_out_schema_1.selectedAutoAggregationOptOut)(command.autoAggregationOptOut, command.columnConfig),
         });
         const restoredReport = await this.lookerStudioReportService.restoreIfDeleted(report);
         const newReport = restoredReport ?? (await this.reportRepository.save(report));

package/dist/src/data-marts/use-cases/get-model-canvas-data-marts.service.d.ts

@@ -5,12 +5,16 @@ import { AccessDecisionService } from '../services/access-decision';
 import { ContextAccessService } from '../services/context/context-access.service';
 import { DataMartService } from '../services/data-mart.service';
 import { DataStorageService } from '../services/data-storage.service';
+import { ReportService } from '../services/report.service';
+import { ScheduledTriggerService } from '../services/scheduled-trigger.service';
 export declare class GetModelCanvasDataMartsService {
     private readonly dataMartService;
     private readonly dataStorageService;
     private readonly contextAccessService;
     private readonly mapper;
     private readonly accessDecisionService;
-    constructor(dataMartService: DataMartService, dataStorageService: DataStorageService, contextAccessService: ContextAccessService, mapper: ModelCanvasMapper, accessDecisionService: AccessDecisionService);
+    private readonly scheduledTriggerService;
+    private readonly reportService;
+    constructor(dataMartService: DataMartService, dataStorageService: DataStorageService, contextAccessService: ContextAccessService, mapper: ModelCanvasMapper, accessDecisionService: AccessDecisionService, scheduledTriggerService: ScheduledTriggerService, reportService: ReportService);
     run(command: GetModelCanvasDataMartsCommand): Promise<ModelCanvasDataMartsDto>;
 }

package/dist/src/data-marts/use-cases/get-model-canvas-data-marts.service.js

@@ -17,6 +17,8 @@ const access_decision_1 = require("../services/access-decision");
 const context_access_service_1 = require("../services/context/context-access.service");
 const data_mart_service_1 = require("../services/data-mart.service");
 const data_storage_service_1 = require("../services/data-storage.service");
+const report_service_1 = require("../services/report.service");
+const scheduled_trigger_service_1 = require("../services/scheduled-trigger.service");
 const CANVAS_DATA_MARTS_PAGE_SIZE = 1000;
 let GetModelCanvasDataMartsService = class GetModelCanvasDataMartsService {
     dataMartService;
@@ -24,12 +26,16 @@ let GetModelCanvasDataMartsService = class GetModelCanvasDataMartsService {
     contextAccessService;
     mapper;
     accessDecisionService;
-    constructor(dataMartService, dataStorageService, contextAccessService, mapper, accessDecisionService) {
+    scheduledTriggerService;
+    reportService;
+    constructor(dataMartService, dataStorageService, contextAccessService, mapper, accessDecisionService, scheduledTriggerService, reportService) {
         this.dataMartService = dataMartService;
         this.dataStorageService = dataStorageService;
         this.contextAccessService = contextAccessService;
         this.mapper = mapper;
         this.accessDecisionService = accessDecisionService;
+        this.scheduledTriggerService = scheduledTriggerService;
+        this.reportService = reportService;
     }
     async run(command) {
         if (!command.userId) {
@@ -52,7 +58,12 @@ let GetModelCanvasDataMartsService = class GetModelCanvasDataMartsService {
             limit: CANVAS_DATA_MARTS_PAGE_SIZE,
             offset,
         });
-        return this.mapper.toDataMartsDto(items, total, offset);
+        const ids = items.map(dataMart => dataMart.id);
+        const [triggerCounts, reportCounts] = await Promise.all([
+            this.scheduledTriggerService.countByDataMartIds(ids),
+            this.reportService.countByDataMartIds(ids),
+        ]);
+        return this.mapper.toDataMartsDto(items, total, offset, { triggerCounts, reportCounts });
     }
 };
 exports.GetModelCanvasDataMartsService = GetModelCanvasDataMartsService;
@@ -62,6 +73,8 @@ exports.GetModelCanvasDataMartsService = GetModelCanvasDataMartsService = __deco
         data_storage_service_1.DataStorageService,
         context_access_service_1.ContextAccessService,
         model_canvas_mapper_1.ModelCanvasMapper,
-        access_decision_1.AccessDecisionService])
+        access_decision_1.AccessDecisionService,
+        scheduled_trigger_service_1.ScheduledTriggerService,
+        report_service_1.ReportService])
 ], GetModelCanvasDataMartsService);
 //# sourceMappingURL=get-model-canvas-data-marts.service.js.map

package/dist/src/data-marts/use-cases/list-project-scheduled-triggers.service.js

@@ -121,7 +121,7 @@ let ListProjectScheduledTriggersService = class ListProjectScheduledTriggersServ
             if (trigger.type === scheduled_trigger_type_enum_1.ScheduledTriggerType.CONNECTOR_RUN &&
                 trigger.dataMart.definition &&
                 (0, data_mart_definition_guards_1.isConnectorDefinition)(trigger.dataMart.definition)) {
-                const maskedDefinition = await this.connectorSecretService.mask(trigger.dataMart.definition);
+                const maskedDefinition = await this.connectorSecretService.mask(projectId, trigger.dataMart.definition);
                 return this.cloneTriggerWithConfig(trigger, {
                     type: ScheduledConnectorRunConfigType,
                     connector: maskedDefinition,

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

@@ -0,0 +1,59 @@
+import { HttpException } from '@nestjs/common';
+import { TypeResolver } from '../../common/resolver/type-resolver';
+import type { Role as RoleType } from '@owox/idp-protocol';
+import { DataStorageType } from '../data-storage-types/enums/data-storage-type.enum';
+import { DataStorageErrorMapper } from '../data-storage-types/interfaces/data-storage-error-mapper.interface';
+import { DataStorageReportReader } from '../data-storage-types/interfaces/data-storage-report-reader.interface';
+import { AccessDecisionService } from '../services/access-decision';
+import { BlendableSchemaService } from '../services/blendable-schema.service';
+import { DataMartService } from '../services/data-mart.service';
+import { ProjectBillingService } from '../services/project-billing/project-billing.service';
+import { ReportSqlComposerService } from '../services/report-sql-composer.service';
+export declare const PREVIEW_DEFAULT_LIMIT = 10;
+export declare const PREVIEW_MAX_LIMIT = 1000;
+export declare const DEFAULT_PREVIEW_DEADLINE_MS = 150000;
+export declare class PreviewDataMartCommand {
+    readonly dataMartId: string;
+    readonly projectId: string;
+    readonly userId: string;
+    readonly roles: RoleType[];
+    readonly limit: number | undefined;
+    readonly filters: unknown;
+    readonly sort: unknown;
+    constructor(dataMartId: string, projectId: string, userId: string, roles: RoleType[], limit: number | undefined, filters: unknown, sort?: unknown);
+}
+export interface DataMartPreviewColumn {
+    name: string;
+    alias?: string;
+    type?: string;
+}
+export type PreviewCell = string | number | boolean | null;
+export interface DataMartPreviewResult {
+    columns: DataMartPreviewColumn[];
+    rows: PreviewCell[][];
+    rowCount: number;
+    limit: number;
+    truncated: boolean;
+}
+export declare const CLIENT_CLOSED_REQUEST_STATUS = 499;
+export declare class PreviewAbortedError extends HttpException {
+    constructor();
+}
+export declare class PreviewDataMartService {
+    private readonly dataMartService;
+    private readonly blendableSchemaService;
+    private readonly composer;
+    private readonly readerResolver;
+    private readonly accessDecisionService;
+    private readonly errorMapperResolver;
+    private readonly projectBillingService;
+    private readonly deadlineMs;
+    private readonly logger;
+    constructor(dataMartService: DataMartService, blendableSchemaService: BlendableSchemaService, composer: ReportSqlComposerService, readerResolver: TypeResolver<DataStorageType, DataStorageReportReader>, accessDecisionService: AccessDecisionService, errorMapperResolver: TypeResolver<DataStorageType, DataStorageErrorMapper>, projectBillingService: ProjectBillingService, deadlineMs?: number);
+    run(command: PreviewDataMartCommand, signal?: AbortSignal): Promise<DataMartPreviewResult>;
+    private parseLimit;
+    private parseSort;
+    private parseFilters;
+    private readRows;
+}
+export declare function toPreviewCell(value: unknown): PreviewCell;

package/dist/src/data-marts/use-cases/preview-data-mart.service.js

@@ -0,0 +1,293 @@
+"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 PreviewDataMartService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreviewDataMartService = exports.PreviewAbortedError = exports.CLIENT_CLOSED_REQUEST_STATUS = exports.PreviewDataMartCommand = exports.DEFAULT_PREVIEW_DEADLINE_MS = exports.PREVIEW_MAX_LIMIT = exports.PREVIEW_DEFAULT_LIMIT = void 0;
+exports.toPreviewCell = toPreviewCell;
+const common_1 = require("@nestjs/common");
+const internal_helpers_1 = require("@owox/internal-helpers");
+const business_violation_exception_1 = require("../../common/exceptions/business-violation.exception");
+const type_resolver_1 = require("../../common/resolver/type-resolver");
+const data_storage_providers_1 = require("../data-storage-types/data-storage-providers");
+const data_mart_schema_utils_1 = require("../data-storage-types/data-mart-schema.utils");
+const filter_config_schema_1 = require("../dto/schemas/filter-config.schema");
+const sort_config_schema_1 = require("../dto/schemas/sort-config.schema");
+const access_decision_1 = require("../services/access-decision");
+const blendable_schema_service_1 = require("../services/blendable-schema.service");
+const data_mart_service_1 = require("../services/data-mart.service");
+const calculated_field_utils_1 = require("../calculated-fields/calculated-field.utils");
+const project_billing_service_1 = require("../services/project-billing/project-billing.service");
+const report_sql_composer_service_1 = require("../services/report-sql-composer.service");
+exports.PREVIEW_DEFAULT_LIMIT = 10;
+exports.PREVIEW_MAX_LIMIT = 1000;
+exports.DEFAULT_PREVIEW_DEADLINE_MS = 150_000;
+class PreviewDataMartCommand {
+    dataMartId;
+    projectId;
+    userId;
+    roles;
+    limit;
+    filters;
+    sort;
+    constructor(dataMartId, projectId, userId, roles, limit, filters, sort = undefined) {
+        this.dataMartId = dataMartId;
+        this.projectId = projectId;
+        this.userId = userId;
+        this.roles = roles;
+        this.limit = limit;
+        this.filters = filters;
+        this.sort = sort;
+    }
+}
+exports.PreviewDataMartCommand = PreviewDataMartCommand;
+exports.CLIENT_CLOSED_REQUEST_STATUS = 499;
+class PreviewAbortedError extends common_1.HttpException {
+    constructor() {
+        super('Preview was cancelled', exports.CLIENT_CLOSED_REQUEST_STATUS);
+        this.name = 'PreviewAbortedError';
+    }
+}
+exports.PreviewAbortedError = PreviewAbortedError;
+let PreviewDataMartService = PreviewDataMartService_1 = class PreviewDataMartService {
+    dataMartService;
+    blendableSchemaService;
+    composer;
+    readerResolver;
+    accessDecisionService;
+    errorMapperResolver;
+    projectBillingService;
+    deadlineMs;
+    logger = new common_1.Logger(PreviewDataMartService_1.name);
+    constructor(dataMartService, blendableSchemaService, composer, readerResolver, accessDecisionService, errorMapperResolver, projectBillingService, deadlineMs = exports.DEFAULT_PREVIEW_DEADLINE_MS) {
+        this.dataMartService = dataMartService;
+        this.blendableSchemaService = blendableSchemaService;
+        this.composer = composer;
+        this.readerResolver = readerResolver;
+        this.accessDecisionService = accessDecisionService;
+        this.errorMapperResolver = errorMapperResolver;
+        this.projectBillingService = projectBillingService;
+        this.deadlineMs = deadlineMs;
+    }
+    async run(command, signal) {
+        const limit = this.parseLimit(command.limit);
+        const filters = this.parseFilters(command.filters);
+        const sort = this.parseSort(command.sort);
+        const dataMart = await this.dataMartService.getByIdAndProjectId(command.dataMartId, command.projectId);
+        const canSee = await this.accessDecisionService.canAccess(command.userId, command.roles, access_decision_1.EntityType.DATA_MART, dataMart.id, access_decision_1.Action.SEE, command.projectId);
+        if (!canSee) {
+            throw new common_1.ForbiddenException('You do not have access to this Data Mart');
+        }
+        const accessor = { userId: command.userId, roles: command.roles };
+        const schema = await this.blendableSchemaService.computeBlendableSchema(dataMart.id, dataMart.projectId, accessor);
+        const calculatedNames = new Set((0, calculated_field_utils_1.calculatedFieldsOf)(schema.nativeFields).map(f => f.name));
+        const fields = schema.nativeFields
+            .filter(data_mart_schema_utils_1.isConnected)
+            .map(field => field.name)
+            .filter(name => !calculatedNames.has(name));
+        if (fields.length === 0) {
+            throw new common_1.BadRequestException('This Data Mart has no visible fields in its Output Schema yet. Refresh the schema, then preview again.');
+        }
+        const readPlan = {
+            dataMart,
+            columnConfig: fields,
+            filterConfig: filters,
+            sortConfig: sort,
+            limitConfig: limit + 1,
+        };
+        throwIfAborted(signal);
+        await this.projectBillingService.verifyCanPerformOperations(dataMart.projectId, project_billing_service_1.RunKind.HTTP_DATA_RUN);
+        throwIfAborted(signal);
+        let result;
+        try {
+            result = await this.readRows(dataMart, readPlan, accessor, schema, limit, signal);
+        }
+        catch (error) {
+            if (error instanceof common_1.HttpException || error instanceof business_violation_exception_1.BusinessViolationException) {
+                throw error;
+            }
+            this.logger.warn(`Preview of Data Mart ${dataMart.id} failed: ${(0, internal_helpers_1.castError)(error).message}`);
+            const mapper = await this.errorMapperResolver.resolve(dataMart.storage.type);
+            throw mapper.toStorageReadError(error, { force: true });
+        }
+        const truncated = result.rows.length > limit;
+        const rows = (truncated ? result.rows.slice(0, limit) : result.rows).map(row => row.map(toPreviewCell));
+        return { columns: result.columns, rows, rowCount: rows.length, limit, truncated };
+    }
+    parseLimit(limit) {
+        if (limit === undefined || limit === null)
+            return exports.PREVIEW_DEFAULT_LIMIT;
+        if (!Number.isInteger(limit) || limit < 1 || limit > exports.PREVIEW_MAX_LIMIT) {
+            throw new common_1.BadRequestException(`limit must be an integer between 1 and ${exports.PREVIEW_MAX_LIMIT}`);
+        }
+        return limit;
+    }
+    parseSort(sort) {
+        if (sort === undefined || sort === null)
+            return null;
+        const parsed = sort_config_schema_1.SortConfigSchema.safeParse(sort);
+        if (!parsed.success) {
+            throw new common_1.BadRequestException({ message: 'Invalid sort', details: parsed.error.issues });
+        }
+        return parsed.data?.length ? parsed.data : null;
+    }
+    parseFilters(filters) {
+        if (filters === undefined || filters === null)
+            return null;
+        const parsed = filter_config_schema_1.FilterConfigSchema.safeParse(filters);
+        if (!parsed.success) {
+            throw new common_1.BadRequestException({
+                message: 'Invalid filters',
+                details: parsed.error.issues,
+            });
+        }
+        return parsed.data?.length ? parsed.data : null;
+    }
+    async readRows(dataMart, readPlan, accessor, schema, limit, signal) {
+        const overReadLimit = limit + 1;
+        const workController = new AbortController();
+        let deadlineTimer;
+        let abortListener;
+        const deadline = new Promise((_, reject) => {
+            deadlineTimer = setTimeout(() => {
+                workController.abort();
+                reject(new common_1.GatewayTimeoutException(`The preview query did not finish within ${Math.round(this.deadlineMs / 1000)} seconds. Add a filter or lower the limit, then try again.`));
+            }, this.deadlineMs);
+        });
+        const aborted = new Promise((_, reject) => {
+            if (!signal)
+                return;
+            if (signal.aborted) {
+                workController.abort();
+                reject(new PreviewAbortedError());
+                return;
+            }
+            abortListener = () => {
+                workController.abort();
+                reject(new PreviewAbortedError());
+            };
+            signal.addEventListener('abort', abortListener, { once: true });
+        });
+        const produce = (async () => {
+            let reader;
+            try {
+                if (workController.signal.aborted)
+                    throw new PreviewAbortedError();
+                const composed = await this.composer.compose(readPlan, accessor, undefined, schema);
+                if (workController.signal.aborted)
+                    throw new PreviewAbortedError();
+                reader = await this.readerResolver.resolve(dataMart.storage.type);
+                if (!reader.honorsQueryTimeout) {
+                    this.logger.warn(`Storage ${dataMart.storage.type} does not honor queryTimeoutMs; a preview it runs is not capped warehouse-side.`);
+                }
+                const description = await reader.prepareReportData(readPlan, {
+                    sqlOverride: composed.sql,
+                    sqlOverrideParams: composed.params,
+                    columnFilter: readPlan.columnConfig ?? undefined,
+                    blendedDataHeaders: composed.blendedDataHeaders,
+                    primaryKeyColumns: composed.primaryKeyColumns,
+                    calculatedFields: composed.calculatedFields,
+                    queryTimeoutMs: this.deadlineMs,
+                    signal: workController.signal,
+                });
+                const columns = description.dataHeaders.map(header => ({
+                    name: header.name,
+                    ...(header.alias ? { alias: header.alias } : {}),
+                    ...(header.storageFieldType ? { type: String(header.storageFieldType) } : {}),
+                }));
+                const rows = [];
+                let batchId;
+                do {
+                    if (workController.signal.aborted)
+                        break;
+                    const batch = await reader.readReportDataBatch(batchId, overReadLimit - rows.length);
+                    rows.push(...batch.dataRows);
+                    batchId = batch.nextDataBatchId ?? undefined;
+                    if (batch.dataRows.length === 0)
+                        break;
+                } while (batchId && rows.length < overReadLimit);
+                return { columns, rows };
+            }
+            finally {
+                workController.abort();
+                try {
+                    await reader?.finalize();
+                }
+                catch (finalizeError) {
+                    this.logger.warn(`reader.finalize() failed; ignoring: ${(0, internal_helpers_1.castError)(finalizeError).message}`);
+                }
+            }
+        })();
+        try {
+            return await Promise.race([produce, deadline, aborted]);
+        }
+        finally {
+            if (deadlineTimer)
+                clearTimeout(deadlineTimer);
+            if (signal && abortListener)
+                signal.removeEventListener('abort', abortListener);
+        }
+    }
+};
+exports.PreviewDataMartService = PreviewDataMartService;
+exports.PreviewDataMartService = PreviewDataMartService = PreviewDataMartService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(3, (0, common_1.Inject)(data_storage_providers_1.DATA_STORAGE_REPORT_READER_RESOLVER)),
+    __param(5, (0, common_1.Inject)(data_storage_providers_1.DATA_STORAGE_ERROR_MAPPER_RESOLVER)),
+    __param(7, (0, common_1.Optional)()),
+    __metadata("design:paramtypes", [data_mart_service_1.DataMartService,
+        blendable_schema_service_1.BlendableSchemaService,
+        report_sql_composer_service_1.ReportSqlComposerService,
+        type_resolver_1.TypeResolver,
+        access_decision_1.AccessDecisionService,
+        type_resolver_1.TypeResolver,
+        project_billing_service_1.ProjectBillingService, Number])
+], PreviewDataMartService);
+function throwIfAborted(signal) {
+    if (signal?.aborted)
+        throw new PreviewAbortedError();
+}
+function toPreviewCell(value) {
+    if (value === null || value === undefined)
+        return null;
+    if (typeof value === 'string' || typeof value === 'boolean')
+        return value;
+    if (typeof value === 'number')
+        return Number.isFinite(value) ? value : String(value);
+    if (typeof value === 'bigint')
+        return value.toString();
+    if (value instanceof Date)
+        return value.toISOString();
+    if (Buffer.isBuffer(value))
+        return value.toString('base64');
+    if (typeof value === 'object') {
+        const toJSON = value.toJSON;
+        if (typeof toJSON === 'function') {
+            const json = toJSON.call(value);
+            if (json !== value)
+                return toPreviewCell(json);
+        }
+        const keys = Object.keys(value);
+        if (keys.length === 1 && keys[0] === 'value') {
+            return toPreviewCell(value.value);
+        }
+        try {
+            return JSON.stringify(value, (_key, inner) => typeof inner === 'bigint' ? inner.toString() : inner);
+        }
+        catch {
+            return String(value);
+        }
+    }
+    return String(value);
+}
+//# sourceMappingURL=preview-data-mart.service.js.map

package/dist/src/data-marts/use-cases/stream-http-data.service.js

@@ -238,6 +238,7 @@ let StreamHttpDataService = StreamHttpDataService_1 = class StreamHttpDataServic
                     aggregationConfig: report.aggregationConfig ?? undefined,
                     dateTruncConfig: report.dateTruncConfig ?? undefined,
                     uniqueCountConfig: report.uniqueCountConfig ?? undefined,
+                    autoAggregationOptOut: report.autoAggregationOptOut ?? undefined,
                     limitConfig: limit ?? report.limitConfig ?? null,
                 };
                 const collapsed = excelReportRun ? (0, auto_collapse_resolver_1.applyAutoCollapse)(basePlan) : undefined;

package/dist/src/data-marts/use-cases/update-data-mart-definition.service.d.ts

@@ -21,7 +21,7 @@ export declare class UpdateDataMartDefinitionService {
     private readonly advancedSearchIndexSync?;
     constructor(dataMartService: DataMartService, mapper: DataMartMapper, connectorSecretService: ConnectorSecretService, legacyDataMartsService: LegacyDataMartsService, accessDecisionService: AccessDecisionService, definitionValidatorFacade: DataMartDefinitionValidatorFacade, eventDispatcher: OwoxEventDispatcher, connectorService: ConnectorService, advancedSearchIndexSync?: AdvancedSearchIndexSyncService | undefined);
     run(command: UpdateDataMartDefinitionCommand): Promise<DataMartDto>;
-    private getConnectorCapabilities;
+    private resolveConnectorCapabilities;
     private validateConnectorConfigurationCount;
     private validateCredentialCopyAccess;
     private validateSecretReferences;