@mbc-cqrs-serverless/import/dist/event/zip-import.sfn.event.handler.js

Import module

"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 ZipImportSfnEventHandler_1;
Object.defineProperty(exports, "__esModule", { value: true });
exports.ZipImportSfnEventHandler = void 0;
const core_1 = require("@mbc-cqrs-serverless/core");
const common_1 = require("@nestjs/common");
const enum_1 = require("../enum");
const import_service_1 = require("../import.service");
const zip_import_sfn_event_1 = require("./zip-import.sfn.event");
let ZipImportSfnEventHandler = ZipImportSfnEventHandler_1 = class ZipImportSfnEventHandler {
    constructor(importService) {
        this.importService = importService;
        this.logger = new common_1.Logger(ZipImportSfnEventHandler_1.name);
    }
    async execute(event) {
        const stateName = event.context.State.Name;
        this.logger.log(`Executing state: ${stateName} for Zip SFN`);
        if (stateName === 'trigger_single_csv_and_wait') {
            return this.triggerSingleCsvJob(event);
        }
        if (stateName === 'finalize_zip_job') {
            return this.finalizeZipMasterJob(event);
        }
        this.logger.warn(`Unknown state name in ZipImportSfnEventHandler: ${stateName}`);
    }
    /**
     * Handles the trigger_single_csv_and_wait state from the orchestrator.
     * It extracts the tableName from the filename and starts a new CSV import job,
     * passing along the taskToken so the orchestrator can be notified upon completion.
     */
    async triggerSingleCsvJob(event) {
        const s3Key = event.input?.s3Key || event.input;
        const { taskToken } = event;
        const { masterJobKey, parameters } = event.context.Execution.Input;
        this.logger.log(`Triggering CSV job for file: ${s3Key}`);
        // Use a regex to extract the table name from the filename.
        // Convention: yyyymmddhhMMss-{table name}.csv
        const match = s3Key.match(/\d{14}-(.+)\.csv$/);
        if (!match || !match[1]) {
            throw new Error(`Could not parse tableName from filename: ${s3Key}. Expected format: yyyymmddhhMMss-{tableName}.csv`);
        }
        const tableName = match[1];
        const dto = {
            processingMode: enum_1.ProcessingMode.STEP_FUNCTION,
            bucket: parameters.bucket,
            key: s3Key,
            tenantCode: parameters.tenantCode,
            tableName: tableName,
        };
        await this.importService.createCsvJobWithTaskToken(dto, taskToken, masterJobKey);
        this.logger.log(`Successfully created CSV job for ${tableName} with task token.`);
    }
    /**
     * Handles the final state of the orchestrator.
     * It aggregates the results from all processed CSV files and sets the final
     * status on the original ZIP_MASTER_JOB.
     */
    async finalizeZipMasterJob(event) {
        const resultsFromMapState = event.input?.processingResults ||
            event.input; // This will be an array of results
        const { masterJobKey } = event.context.Execution.Input;
        this.logger.log(`Finalizing ZIP master job: ${masterJobKey.pk}#${masterJobKey.sk}`);
        this.logger.debug('Aggregated results:', resultsFromMapState);
        // Aggregate the results from each CSV file's processing.
        const finalSummary = resultsFromMapState.reduce((acc, result) => {
            const res = result?.result || result || {};
            acc.totalRows += res.total || res.totalRows || 0;
            acc.processedRows += res.succeeded || res.processedRows || 0;
            acc.failedRows += res.failed || res.failedRows || 0;
            return acc;
        }, { totalRows: 0, processedRows: 0, failedRows: 0 });
        const finalStatus = enum_1.ImportStatusEnum.COMPLETED;
        await this.importService.updateStatus(masterJobKey, finalStatus, {
            result: finalSummary,
        });
        this.logger.log(`Successfully finalized ZIP master job ${masterJobKey.pk}#${masterJobKey.sk} with status ${finalStatus}`);
    }
};
exports.ZipImportSfnEventHandler = ZipImportSfnEventHandler;
exports.ZipImportSfnEventHandler = ZipImportSfnEventHandler = ZipImportSfnEventHandler_1 = __decorate([
    (0, common_1.Injectable)(),
    (0, core_1.EventHandler)(zip_import_sfn_event_1.ZipImportSfnEvent),
    __metadata("design:paramtypes", [import_service_1.ImportService])
], ZipImportSfnEventHandler);
//# sourceMappingURL=zip-import.sfn.event.handler.js.map