@owox/backend 0.35.0 → 0.36.0

package/dist/src/data-marts/connector-types/connector-message/services/connector-event.translator.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NEW_EVENT_TYPES = void 0;
+exports.isNewEvent = isNewEvent;
+exports.translateNewEventToLegacy = translateNewEventToLegacy;
+const connectors_1 = require("@owox/connectors");
+const connector_message_type_enum_1 = require("../../enums/connector-message-type-enum");
+const EVENT_TYPE = connectors_1.Core.EVENT_TYPE;
+const LOG_LEVEL = connectors_1.Core.LOG_LEVEL;
+const CONTROL_ACTION = connectors_1.Core
+    .CONTROL_ACTION;
+const EXECUTION_STATUS = connectors_1.Core
+    .EXECUTION_STATUS;
+exports.NEW_EVENT_TYPES = [
+    EVENT_TYPE.LOG,
+    EVENT_TYPE.DATA,
+    EVENT_TYPE.TRACE,
+    EVENT_TYPE.ANALYTICS,
+    EVENT_TYPE.STATE,
+    EVENT_TYPE.CONTROL,
+    EVENT_TYPE.CREDENTIALS,
+    EVENT_TYPE.FIELDS,
+];
+const LEGACY_STATUS_IMPORT_DONE = EXECUTION_STATUS.IMPORT_DONE;
+function isNewEvent(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const t = value.type;
+    if (typeof t !== 'string')
+        return false;
+    return exports.NEW_EVENT_TYPES.includes(t);
+}
+function translateNewEventToLegacy(event) {
+    const at = typeof event.timestamp === 'string' ? event.timestamp : new Date().toISOString();
+    const type = event.type;
+    const legacy = translateEventBody(event, type, at);
+    if (legacy !== null) {
+        legacy.eventType = type;
+    }
+    return legacy;
+}
+function translateEventBody(event, type, at) {
+    switch (type) {
+        case EVENT_TYPE.LOG: {
+            const level = typeof event.level === 'string' ? event.level : LOG_LEVEL.INFO;
+            const message = typeof event.message === 'string' ? event.message : JSON.stringify(event);
+            if (level === LOG_LEVEL.ERROR) {
+                return { type: connector_message_type_enum_1.ConnectorMessageType.ERROR, at, error: message };
+            }
+            if (level === LOG_LEVEL.WARN || level === 'warning') {
+                return { type: connector_message_type_enum_1.ConnectorMessageType.WARNING, at, warning: message };
+            }
+            return { type: connector_message_type_enum_1.ConnectorMessageType.LOG, at, message };
+        }
+        case EVENT_TYPE.CONTROL: {
+            const action = typeof event.action === 'string' ? event.action : 'unknown';
+            if (action === CONTROL_ACTION.COMPLETED) {
+                return { type: connector_message_type_enum_1.ConnectorMessageType.STATUS, at, status: LEGACY_STATUS_IMPORT_DONE };
+            }
+            if (action === CONTROL_ACTION.FAILED) {
+                const error = typeof event.error === 'string' && event.error.length > 0
+                    ? event.error
+                    : 'Connector reported failure';
+                return { type: connector_message_type_enum_1.ConnectorMessageType.ERROR, at, error };
+            }
+            return {
+                type: connector_message_type_enum_1.ConnectorMessageType.LOG,
+                at,
+                message: `[CONTROL] ${action}`,
+            };
+        }
+        case EVENT_TYPE.STATE: {
+            const state = (event.state ?? {});
+            const lastRequestedDate = state.lastRequestedDate;
+            if (typeof lastRequestedDate === 'string' && lastRequestedDate.length > 0) {
+                return {
+                    type: connector_message_type_enum_1.ConnectorMessageType.REQUESTED_DATE,
+                    at,
+                    date: lastRequestedDate,
+                };
+            }
+            if (Object.keys(state).length > 0) {
+                return {
+                    type: connector_message_type_enum_1.ConnectorMessageType.STATE_UPDATE,
+                    at,
+                    state,
+                };
+            }
+            return {
+                type: connector_message_type_enum_1.ConnectorMessageType.LOG,
+                at,
+                message: `[STATE] ${JSON.stringify(state)}`,
+            };
+        }
+        case EVENT_TYPE.TRACE: {
+            const action = typeof event.action === 'string' ? event.action : 'trace';
+            const details = event.details !== undefined ? JSON.stringify(event.details) : '';
+            return {
+                type: connector_message_type_enum_1.ConnectorMessageType.LOG,
+                at,
+                message: `[TRACE] ${action}${details ? ` ${details}` : ''}`,
+            };
+        }
+        case EVENT_TYPE.ANALYTICS: {
+            const metric = typeof event.metric === 'string' ? event.metric : 'metric';
+            const value = event.value;
+            const tags = event.tags && typeof event.tags === 'object'
+                ? event.tags
+                : undefined;
+            const tagsText = tags !== undefined ? ` ${JSON.stringify(tags)}` : '';
+            return {
+                type: connector_message_type_enum_1.ConnectorMessageType.LOG,
+                at,
+                metric,
+                value,
+                ...(tags !== undefined ? { tags } : {}),
+                message: `[ANALYTICS] ${metric}=${JSON.stringify(value)}${tagsText}`,
+            };
+        }
+        case EVENT_TYPE.CREDENTIALS: {
+            const credentials = event.credentials && typeof event.credentials === 'object'
+                ? event.credentials
+                : {};
+            return { type: connector_message_type_enum_1.ConnectorMessageType.CREDENTIALS_UPDATE, at, credentials };
+        }
+        case EVENT_TYPE.FIELDS: {
+            const fields = Array.isArray(event.fields)
+                ? event.fields.filter((field) => typeof field === 'string')
+                : [];
+            return { type: connector_message_type_enum_1.ConnectorMessageType.FIELDS_UPDATE, at, fields };
+        }
+        case EVENT_TYPE.DATA:
+            return null;
+        default:
+            return null;
+    }
+}
+//# sourceMappingURL=connector-event.translator.js.map

package/dist/src/data-marts/connector-types/connector-message/services/connector-message-parser.service.d.ts

@@ -1,9 +1,7 @@
 import { ConnectorMessage } from '../schemas/connector-message.schema';
 export declare class ConnectorMessageParserService {
     private logger;
-    parse(message: string): ConnectorMessage;
+    parse(message: string): ConnectorMessage | null;
     private parseAsUnknown;
     private redactCredentialUpdateMessage;
-    private redactCredentialUpdateJson;
-    private hasCredentialUpdateContent;
 }

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

@@ -12,26 +12,45 @@ const common_1 = require("@nestjs/common");
 const connector_message_schema_1 = require("../schemas/connector-message.schema");
 const connector_message_type_enum_1 = require("../../enums/connector-message-type-enum");
 const connectors_1 = require("@owox/connectors");
+const connector_event_translator_1 = require("./connector-event.translator");
 const { GENERATED_REFRESH_TOKEN_CREDENTIAL_FIELD } = connectors_1.Core;
+const MAX_DESCRIBED_KEYS = 20;
+function describeShape(value) {
+    if (value === null)
+        return 'null';
+    if (Array.isArray(value))
+        return `array(${value.length})`;
+    if (typeof value !== 'object')
+        return typeof value;
+    const keys = Object.keys(value);
+    const shown = keys.slice(0, MAX_DESCRIBED_KEYS);
+    const omitted = keys.length - shown.length;
+    return `object{${shown.join(', ')}${omitted > 0 ? `, +${omitted} more` : ''}}`;
+}
 let ConnectorMessageParserService = ConnectorMessageParserService_1 = class ConnectorMessageParserService {
     logger = new common_1.Logger(ConnectorMessageParserService_1.name);
     parse(message) {
+        let asJson;
         try {
-            const asJson = JSON.parse(message);
-            const parsedMessage = connector_message_schema_1.ConnectorMessageSchema.safeParse(asJson);
-            if (!parsedMessage.success) {
-                this.logger.warn(`Schema validation failed for message:`, {
-                    message: this.redactCredentialUpdateMessage(message),
-                    parsedJson: this.redactCredentialUpdateJson(asJson),
-                    errors: parsedMessage.error.errors,
-                });
-                return this.parseAsUnknown(message);
-            }
-            return parsedMessage.data;
+            asJson = JSON.parse(message);
         }
         catch {
             return this.parseAsUnknown(message);
         }
+        const candidate = (0, connector_event_translator_1.isNewEvent)(asJson) ? (0, connector_event_translator_1.translateNewEventToLegacy)(asJson) : asJson;
+        if (candidate === null) {
+            return null;
+        }
+        const parsedMessage = connector_message_schema_1.ConnectorMessageSchema.safeParse(candidate);
+        if (!parsedMessage.success) {
+            this.logger.warn(`Schema validation failed for message:`, {
+                messageLength: message.length,
+                shape: describeShape(asJson),
+                errors: parsedMessage.error.errors,
+            });
+            return this.parseAsUnknown(message);
+        }
+        return parsedMessage.data;
     }
     parseAsUnknown(message) {
         const safeMessage = this.redactCredentialUpdateMessage(message).trim();
@@ -49,29 +68,6 @@ let ConnectorMessageParserService = ConnectorMessageParserService_1 = class Conn
         }
         return '[REDACTED updateCredentials message]';
     }
-    redactCredentialUpdateJson(value) {
-        if (!value || typeof value !== 'object') {
-            return value;
-        }
-        if (!this.hasCredentialUpdateContent(value)) {
-            return value;
-        }
-        return '[REDACTED updateCredentials message]';
-    }
-    hasCredentialUpdateContent(value) {
-        if (!value || typeof value !== 'object') {
-            return false;
-        }
-        if (Array.isArray(value)) {
-            return value.some(item => this.hasCredentialUpdateContent(item));
-        }
-        const objectValue = value;
-        if (objectValue.type === connector_message_type_enum_1.ConnectorMessageType.CREDENTIALS_UPDATE ||
-            Object.prototype.hasOwnProperty.call(objectValue, GENERATED_REFRESH_TOKEN_CREDENTIAL_FIELD)) {
-            return true;
-        }
-        return Object.values(objectValue).some(item => this.hasCredentialUpdateContent(item));
-    }
 };
 exports.ConnectorMessageParserService = ConnectorMessageParserService;
 exports.ConnectorMessageParserService = ConnectorMessageParserService = ConnectorMessageParserService_1 = __decorate([

package/dist/src/data-marts/connector-types/connector-message/services/connector-output-capture.service.js

@@ -29,24 +29,22 @@ let ConnectorOutputCaptureService = class ConnectorOutputCaptureService {
         };
     }
     captureMessage(message) {
-        return this.cleanMessage(message).map(line => {
-            const parsedMessage = this.connectorMessageParserService.parse(line);
-            return parsedMessage;
-        });
+        return this.cleanMessage(message)
+            .map(line => this.connectorMessageParserService.parse(line))
+            .filter((parsed) => parsed !== null);
     }
     captureError(message) {
-        return this.cleanMessage(message).map(line => {
-            const parsedMessage = this.connectorMessageParserService.parse(line);
-            if (parsedMessage.type !== connector_message_type_enum_1.ConnectorMessageType.UNKNOWN) {
-                return parsedMessage;
-            }
-            return {
+        return this.cleanMessage(message)
+            .map(line => this.connectorMessageParserService.parse(line))
+            .filter((parsed) => parsed !== null)
+            .map(parsedMessage => parsedMessage.type !== connector_message_type_enum_1.ConnectorMessageType.UNKNOWN
+            ? parsedMessage
+            : {
                 type: connector_message_type_enum_1.ConnectorMessageType.ERROR,
                 at: parsedMessage.at,
                 error: parsedMessage.toFormattedString(),
                 toFormattedString: () => `[ERROR] ${parsedMessage.toFormattedString()}`,
-            };
-        });
+            });
     }
     cleanMessage(message) {
         const trimmed = message.trim();

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

@@ -39,9 +39,11 @@ let ConnectorStateService = class ConnectorStateService {
             where: { datamartId: dataMartId },
         });
         const now = new Date().toISOString();
+        const previousState = existingState?.state?.states?.find((s) => s._id === configId)?.state ??
+            {};
         const newStateItem = {
             _id: configId,
-            state: outputState.state || {},
+            state: { ...previousState, ...(outputState.state || {}) },
             at: outputState.at || now,
         };
         if (existingState) {

package/dist/src/data-marts/connector-types/enums/connector-message-type-enum.d.ts

@@ -6,6 +6,7 @@ export declare enum ConnectorMessageType {
     CREDENTIALS_UPDATE = "updateCredentials",
     FIELDS_UPDATE = "updateFields",
     REQUESTED_DATE = "updateLastRequstedDate",
+    STATE_UPDATE = "updateState",
     WARNING = "addWarningToCurrentStatus",
     UNKNOWN = "unknown",
     ERROR = "error"

package/dist/src/data-marts/connector-types/enums/connector-message-type-enum.js

@@ -10,6 +10,7 @@ var ConnectorMessageType;
     ConnectorMessageType["CREDENTIALS_UPDATE"] = "updateCredentials";
     ConnectorMessageType["FIELDS_UPDATE"] = "updateFields";
     ConnectorMessageType["REQUESTED_DATE"] = "updateLastRequstedDate";
+    ConnectorMessageType["STATE_UPDATE"] = "updateState";
     ConnectorMessageType["WARNING"] = "addWarningToCurrentStatus";
     ConnectorMessageType["UNKNOWN"] = "unknown";
     ConnectorMessageType["ERROR"] = "error";

package/dist/src/data-marts/controllers/connector-definition.controller.d.ts

@@ -0,0 +1,30 @@
+import { AuthorizationContext } from '../../idp';
+import { ConnectorFieldsResponseApiDto } from '../dto/presentation/connector-fields-response-api.dto';
+import { ConnectorSpecificationResponseApiDto } from '../dto/presentation/connector-specification-response-api.dto';
+import { ConnectorDefinitionService } from '../services/connector/connector-definition.service';
+import { ConnectorService } from '../services/connector/connector.service';
+import { ConnectorTestService } from '../services/connector/connector-test.service';
+import { CreateCustomConnectorRequestApiDto, SaveDraftRequestApiDto, TestConnectorRequestApiDto, UpdateCustomConnectorRequestApiDto } from '../dto/presentation/custom-connector.dto';
+import { ActivateCustomConnectorVersionResponseApiDto, ConnectorTestResultResponseApiDto, CreateCustomConnectorResponseApiDto, CustomConnectorDetailResponseApiDto, CustomConnectorListItemResponseApiDto, CustomConnectorVersionResponseApiDto, CustomConnectorVersionStateResponseApiDto, DeleteCustomConnectorResponseApiDto, PublishCustomConnectorResponseApiDto } from '../dto/presentation/custom-connector-response.dto';
+import { ConnectorDefinitionMapper } from '../mappers/connector-definition.mapper';
+import { ConnectorMapper } from '../mappers/connector.mapper';
+export declare class ConnectorDefinitionController {
+    private readonly definitionService;
+    private readonly connectorService;
+    private readonly testService;
+    private readonly mapper;
+    private readonly connectorMapper;
+    constructor(definitionService: ConnectorDefinitionService, connectorService: ConnectorService, testService: ConnectorTestService, mapper: ConnectorDefinitionMapper, connectorMapper: ConnectorMapper);
+    list(ctx: AuthorizationContext): Promise<CustomConnectorListItemResponseApiDto[]>;
+    create(ctx: AuthorizationContext, body: CreateCustomConnectorRequestApiDto): Promise<CreateCustomConnectorResponseApiDto>;
+    test(ctx: AuthorizationContext, body: TestConnectorRequestApiDto): Promise<ConnectorTestResultResponseApiDto>;
+    get(ctx: AuthorizationContext, id: string): Promise<CustomConnectorDetailResponseApiDto>;
+    update(ctx: AuthorizationContext, id: string, body: UpdateCustomConnectorRequestApiDto): Promise<CustomConnectorDetailResponseApiDto>;
+    getVersion(ctx: AuthorizationContext, id: string, version: number): Promise<CustomConnectorVersionResponseApiDto>;
+    saveDraft(ctx: AuthorizationContext, id: string, body: SaveDraftRequestApiDto): Promise<CustomConnectorVersionStateResponseApiDto>;
+    publish(ctx: AuthorizationContext, id: string): Promise<PublishCustomConnectorResponseApiDto>;
+    activate(ctx: AuthorizationContext, id: string, version: number): Promise<ActivateCustomConnectorVersionResponseApiDto>;
+    remove(ctx: AuthorizationContext, id: string): Promise<DeleteCustomConnectorResponseApiDto>;
+    specification(ctx: AuthorizationContext, id: string, version?: number): Promise<ConnectorSpecificationResponseApiDto[]>;
+    fields(ctx: AuthorizationContext, id: string, version?: number): Promise<ConnectorFieldsResponseApiDto[]>;
+}

package/dist/src/data-marts/controllers/connector-definition.controller.js

@@ -0,0 +1,252 @@
+"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.ConnectorDefinitionController = void 0;
+const common_1 = require("@nestjs/common");
+const swagger_1 = require("@nestjs/swagger");
+const idp_1 = require("../../idp");
+const decorators_1 = require("../../idp/decorators");
+const role_config_types_1 = require("../../idp/types/role-config.types");
+const connector_definition_service_1 = require("../services/connector/connector-definition.service");
+const connector_service_1 = require("../services/connector/connector.service");
+const connector_test_service_1 = require("../services/connector/connector-test.service");
+const custom_connector_dto_1 = require("../dto/presentation/custom-connector.dto");
+const connector_definition_mapper_1 = require("../mappers/connector-definition.mapper");
+const connector_mapper_1 = require("../mappers/connector.mapper");
+const connector_definition_api_1 = require("./spec/connector-definition.api");
+let ConnectorDefinitionController = class ConnectorDefinitionController {
+    definitionService;
+    connectorService;
+    testService;
+    mapper;
+    connectorMapper;
+    constructor(definitionService, connectorService, testService, mapper, connectorMapper) {
+        this.definitionService = definitionService;
+        this.connectorService = connectorService;
+        this.testService = testService;
+        this.mapper = mapper;
+        this.connectorMapper = connectorMapper;
+    }
+    async list(ctx) {
+        const defs = await this.definitionService.listByProject(ctx.projectId);
+        const activeVersionByDefId = await this.definitionService.getActiveVersionNumbersByDefId(defs);
+        return this.mapper.toListResponse(defs, activeVersionByDefId);
+    }
+    async create(ctx, body) {
+        const def = await this.definitionService.create(ctx.projectId, ctx.userId, {
+            name: body.name,
+            title: body.title,
+            description: body.description ?? null,
+            logo: body.logo ?? null,
+            docUrl: body.docUrl ?? null,
+            manifest: body.manifest,
+        });
+        return this.mapper.toCreateResponse(def);
+    }
+    async test(ctx, body) {
+        return this.testService.runTest({
+            projectId: ctx.projectId,
+            manifest: body.manifest,
+            node: body.node,
+            configuration: body.configuration,
+            maxRows: body.maxRows,
+            maxPages: body.maxPages,
+        });
+    }
+    async get(ctx, id) {
+        const def = await this.definitionService.getById(ctx.projectId, id);
+        const versions = await this.definitionService.listVersions(ctx.projectId, id);
+        const activeVersion = await this.definitionService.getActiveVersionNumberForDef(def);
+        return this.mapper.toDetailResponse(def, versions, activeVersion);
+    }
+    async update(ctx, id, body) {
+        const def = await this.definitionService.updateMetadata(ctx.projectId, id, body);
+        const versions = await this.definitionService.listVersions(ctx.projectId, id);
+        const activeVersion = await this.definitionService.getActiveVersionNumberForDef(def);
+        return this.mapper.toDetailResponse(def, versions, activeVersion);
+    }
+    async getVersion(ctx, id, version) {
+        const row = await this.definitionService.getVersion(ctx.projectId, id, version);
+        return this.mapper.toVersionResponse(row);
+    }
+    async saveDraft(ctx, id, body) {
+        const row = await this.definitionService.saveDraft(ctx.projectId, id, body.manifest);
+        return this.mapper.toVersionStateResponse(row);
+    }
+    async publish(ctx, id) {
+        const { version: row, warnings } = await this.definitionService.publish(ctx.projectId, id, {
+            userId: ctx.userId,
+            roles: ctx.roles ?? [],
+        });
+        return this.mapper.toPublishResponse(row, warnings);
+    }
+    async activate(ctx, id, version) {
+        const def = await this.definitionService.setActiveVersion(ctx.projectId, id, version, {
+            userId: ctx.userId,
+            roles: ctx.roles ?? [],
+        });
+        return this.mapper.toActivateResponse(def, version);
+    }
+    async remove(ctx, id) {
+        await this.definitionService.softDelete(ctx.projectId, id);
+        return { success: true };
+    }
+    async specification(ctx, id, version) {
+        const def = await this.definitionService.getById(ctx.projectId, id);
+        const manifest = await this.definitionService.resolveManifest(ctx.projectId, def.name, version);
+        return this.connectorMapper.toSpecificationResponse(this.connectorService.getSpecificationFromManifest(manifest));
+    }
+    async fields(ctx, id, version) {
+        const def = await this.definitionService.getById(ctx.projectId, id);
+        const manifest = await this.definitionService.resolveManifest(ctx.projectId, def.name, version);
+        return this.connectorMapper.toFieldsResponse(this.connectorService.getFieldsSchemaFromManifest(manifest));
+    }
+};
+exports.ConnectorDefinitionController = ConnectorDefinitionController;
+__decorate([
+    (0, idp_1.Auth)(role_config_types_1.Role.viewer()),
+    (0, common_1.Get)(),
+    (0, connector_definition_api_1.ListCustomConnectorsSpec)(),
+    __param(0, (0, idp_1.AuthContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], ConnectorDefinitionController.prototype, "list", null);
+__decorate([
+    (0, idp_1.Auth)(role_config_types_1.Role.editor()),
+    (0, common_1.Post)(),
+    (0, connector_definition_api_1.CreateCustomConnectorSpec)(),
+    __param(0, (0, idp_1.AuthContext)()),
+    __param(1, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, custom_connector_dto_1.CreateCustomConnectorRequestApiDto]),
+    __metadata("design:returntype", Promise)
+], ConnectorDefinitionController.prototype, "create", null);
+__decorate([
+    (0, idp_1.Auth)(role_config_types_1.Role.editor()),
+    (0, common_1.Post)('test'),
+    (0, connector_definition_api_1.TestCustomConnectorSpec)(),
+    __param(0, (0, idp_1.AuthContext)()),
+    __param(1, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, custom_connector_dto_1.TestConnectorRequestApiDto]),
+    __metadata("design:returntype", Promise)
+], ConnectorDefinitionController.prototype, "test", null);
+__decorate([
+    (0, idp_1.Auth)(role_config_types_1.Role.viewer()),
+    (0, common_1.Get)(':id'),
+    (0, connector_definition_api_1.GetCustomConnectorSpec)(),
+    __param(0, (0, idp_1.AuthContext)()),
+    __param(1, (0, common_1.Param)('id')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String]),
+    __metadata("design:returntype", Promise)
+], ConnectorDefinitionController.prototype, "get", null);
+__decorate([
+    (0, idp_1.Auth)(role_config_types_1.Role.editor()),
+    (0, common_1.Patch)(':id'),
+    (0, connector_definition_api_1.UpdateCustomConnectorSpec)(),
+    __param(0, (0, idp_1.AuthContext)()),
+    __param(1, (0, common_1.Param)('id')),
+    __param(2, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String, custom_connector_dto_1.UpdateCustomConnectorRequestApiDto]),
+    __metadata("design:returntype", Promise)
+], ConnectorDefinitionController.prototype, "update", null);
+__decorate([
+    (0, idp_1.Auth)(role_config_types_1.Role.editor()),
+    (0, common_1.Get)(':id/versions/:version'),
+    (0, connector_definition_api_1.GetCustomConnectorVersionSpec)(),
+    __param(0, (0, idp_1.AuthContext)()),
+    __param(1, (0, common_1.Param)('id')),
+    __param(2, (0, common_1.Param)('version', common_1.ParseIntPipe)),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String, Number]),
+    __metadata("design:returntype", Promise)
+], ConnectorDefinitionController.prototype, "getVersion", null);
+__decorate([
+    (0, idp_1.Auth)(role_config_types_1.Role.editor()),
+    (0, common_1.Put)(':id/draft'),
+    (0, connector_definition_api_1.SaveCustomConnectorDraftSpec)(),
+    __param(0, (0, idp_1.AuthContext)()),
+    __param(1, (0, common_1.Param)('id')),
+    __param(2, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String, custom_connector_dto_1.SaveDraftRequestApiDto]),
+    __metadata("design:returntype", Promise)
+], ConnectorDefinitionController.prototype, "saveDraft", null);
+__decorate([
+    (0, idp_1.Auth)(role_config_types_1.Role.editor()),
+    (0, common_1.Post)(':id/publish'),
+    (0, connector_definition_api_1.PublishCustomConnectorSpec)(),
+    __param(0, (0, idp_1.AuthContext)()),
+    __param(1, (0, common_1.Param)('id')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String]),
+    __metadata("design:returntype", Promise)
+], ConnectorDefinitionController.prototype, "publish", null);
+__decorate([
+    (0, idp_1.Auth)(role_config_types_1.Role.editor()),
+    (0, common_1.Post)(':id/versions/:version/activate'),
+    (0, connector_definition_api_1.ActivateCustomConnectorVersionSpec)(),
+    __param(0, (0, idp_1.AuthContext)()),
+    __param(1, (0, common_1.Param)('id')),
+    __param(2, (0, common_1.Param)('version', common_1.ParseIntPipe)),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String, Number]),
+    __metadata("design:returntype", Promise)
+], ConnectorDefinitionController.prototype, "activate", null);
+__decorate([
+    (0, idp_1.Auth)(role_config_types_1.Role.editor()),
+    (0, common_1.Delete)(':id'),
+    (0, connector_definition_api_1.DeleteCustomConnectorSpec)(),
+    __param(0, (0, idp_1.AuthContext)()),
+    __param(1, (0, common_1.Param)('id')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String]),
+    __metadata("design:returntype", Promise)
+], ConnectorDefinitionController.prototype, "remove", null);
+__decorate([
+    (0, idp_1.Auth)(role_config_types_1.Role.viewer()),
+    (0, common_1.Get)(':id/specification'),
+    (0, connector_definition_api_1.GetCustomConnectorSpecificationSpec)(),
+    __param(0, (0, idp_1.AuthContext)()),
+    __param(1, (0, common_1.Param)('id')),
+    __param(2, (0, common_1.Query)('version', new common_1.ParseIntPipe({ optional: true }))),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String, Number]),
+    __metadata("design:returntype", Promise)
+], ConnectorDefinitionController.prototype, "specification", null);
+__decorate([
+    (0, idp_1.Auth)(role_config_types_1.Role.viewer()),
+    (0, common_1.Get)(':id/fields'),
+    (0, connector_definition_api_1.GetCustomConnectorFieldsSpec)(),
+    __param(0, (0, idp_1.AuthContext)()),
+    __param(1, (0, common_1.Param)('id')),
+    __param(2, (0, common_1.Query)('version', new common_1.ParseIntPipe({ optional: true }))),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String, Number]),
+    __metadata("design:returntype", Promise)
+], ConnectorDefinitionController.prototype, "fields", null);
+exports.ConnectorDefinitionController = ConnectorDefinitionController = __decorate([
+    (0, common_1.Controller)('connectors/custom'),
+    (0, swagger_1.ApiTags)('Custom Connectors'),
+    (0, decorators_1.RejectPluginAuth)(),
+    __metadata("design:paramtypes", [connector_definition_service_1.ConnectorDefinitionService,
+        connector_service_1.ConnectorService,
+        connector_test_service_1.ConnectorTestService,
+        connector_definition_mapper_1.ConnectorDefinitionMapper,
+        connector_mapper_1.ConnectorMapper])
+], ConnectorDefinitionController);
+//# sourceMappingURL=connector-definition.controller.js.map

package/dist/src/data-marts/controllers/data-mart-preview.controller.d.ts

@@ -0,0 +1,10 @@
+import type { Response } from 'express';
+import { AuthorizationContext } from '../../idp';
+import { PreviewDataMartRequestApiDto } from '../dto/presentation/preview-data-mart-request-api.dto';
+import { PreviewDataMartResponseApiDto } from '../dto/presentation/preview-data-mart-response-api.dto';
+import { PreviewDataMartService } from '../use-cases/preview-data-mart.service';
+export declare class DataMartPreviewController {
+    private readonly previewDataMartService;
+    constructor(previewDataMartService: PreviewDataMartService);
+    preview(context: AuthorizationContext, id: string, dto: PreviewDataMartRequestApiDto, response: Response): Promise<PreviewDataMartResponseApiDto>;
+}

package/dist/src/data-marts/controllers/data-mart-preview.controller.js

@@ -0,0 +1,58 @@
+"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.DataMartPreviewController = void 0;
+const common_1 = require("@nestjs/common");
+const swagger_1 = require("@nestjs/swagger");
+const idp_1 = require("../../idp");
+const preview_data_mart_request_api_dto_1 = require("../dto/presentation/preview-data-mart-request-api.dto");
+const preview_data_mart_response_api_dto_1 = require("../dto/presentation/preview-data-mart-response-api.dto");
+const preview_data_mart_service_1 = require("../use-cases/preview-data-mart.service");
+let DataMartPreviewController = class DataMartPreviewController {
+    previewDataMartService;
+    constructor(previewDataMartService) {
+        this.previewDataMartService = previewDataMartService;
+    }
+    async preview(context, id, dto, response) {
+        const abortController = new AbortController();
+        response.on('close', () => {
+            if (!response.writableFinished)
+                abortController.abort();
+        });
+        return this.previewDataMartService.run(new preview_data_mart_service_1.PreviewDataMartCommand(id, context.projectId, context.userId, context.roles ?? [], dto.limit, dto.filters, dto.sort), abortController.signal);
+    }
+};
+exports.DataMartPreviewController = DataMartPreviewController;
+__decorate([
+    (0, idp_1.Auth)(idp_1.Role.viewer(idp_1.Strategy.INTROSPECT)),
+    (0, idp_1.RejectApiKeyAuth)(),
+    (0, idp_1.RejectPluginAuth)(),
+    (0, common_1.Post)(':id/preview'),
+    (0, common_1.HttpCode)(200),
+    (0, swagger_1.ApiOperation)({ summary: 'Read a sample of Data Mart rows for the Data Setup preview' }),
+    (0, swagger_1.ApiOkResponse)({ type: preview_data_mart_response_api_dto_1.PreviewDataMartResponseApiDto }),
+    __param(0, (0, idp_1.AuthContext)()),
+    __param(1, (0, common_1.Param)('id')),
+    __param(2, (0, common_1.Body)()),
+    __param(3, (0, common_1.Res)({ passthrough: true })),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String, preview_data_mart_request_api_dto_1.PreviewDataMartRequestApiDto, Object]),
+    __metadata("design:returntype", Promise)
+], DataMartPreviewController.prototype, "preview", null);
+exports.DataMartPreviewController = DataMartPreviewController = __decorate([
+    (0, common_1.Controller)('data-marts'),
+    (0, swagger_1.ApiTags)('DataMarts'),
+    __metadata("design:paramtypes", [preview_data_mart_service_1.PreviewDataMartService])
+], DataMartPreviewController);
+//# sourceMappingURL=data-mart-preview.controller.js.map