@mbc-cqrs-serverless/core/dist/commands/data.service.js

CQRS and event base core

"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 DataService_1;
Object.defineProperty(exports, "__esModule", { value: true });
exports.DataService = void 0;
const common_1 = require("@nestjs/common");
const dynamodb_service_1 = require("../data-store/dynamodb.service");
const key_1 = require("../helpers/key");
const interfaces_1 = require("../interfaces");
const command_module_definition_1 = require("./command.module-definition");
const enums_1 = require("./enums");
const TABLE_NAME = Symbol('data');
/**
 * Service for reading data from DynamoDB.
 * Provides query operations for the read side of CQRS.
 *
 * @example
 * ```typescript
 * @Injectable()
 * export class OrderService {
 *   constructor(
 *     @InjectDataService() private readonly dataService: DataService
 *   ) {}
 *
 *   async getOrder(pk: string, sk: string) {
 *     return this.dataService.getItem({ pk, sk });
 *   }
 * }
 * ```
 */
let DataService = DataService_1 = class DataService {
    constructor(options, dynamoDbService) {
        this.options = options;
        this.dynamoDbService = dynamoDbService;
        this.tableName = this.dynamoDbService.getTableName(this.options.tableName, enums_1.TableType.DATA);
        this.logger = new common_1.Logger(`${DataService_1.name}:${this.tableName}`);
    }
    set tableName(name) {
        this[TABLE_NAME] = name;
    }
    get tableName() {
        return this[TABLE_NAME];
    }
    /**
     * Publishes command data to the data table.
     * Updates or creates the data record based on the command.
     *
     * @param cmd - The command model to publish
     * @returns The published data model
     */
    async publish(cmd) {
        const pk = cmd.pk;
        const sk = (0, key_1.removeSortKeyVersion)(cmd.sk);
        const data = await this.getItem({ pk, sk });
        const dataModel = {
            ...data,
            pk,
            sk,
            id: cmd.id,
            code: cmd.code,
            name: cmd.name,
            version: cmd.version,
            tenantCode: cmd.tenantCode,
            type: cmd.type,
            seq: cmd.seq,
            attributes: cmd.attributes,
            cpk: cmd.pk,
            csk: cmd.sk,
            isDeleted: cmd.isDeleted,
            ttl: cmd.ttl,
            requestId: cmd.requestId,
            createdAt: data?.createdAt || cmd.createdAt,
            updatedAt: cmd.updatedAt,
            createdBy: data?.createdBy || cmd.createdBy,
            updatedBy: cmd.updatedBy,
            createdIp: data?.createdIp || cmd.createdIp,
            updatedIp: cmd.updatedIp,
        };
        this.logger.debug('publish::', dataModel);
        await this.dynamoDbService.putItem(this.tableName, dataModel);
        return dataModel;
    }
    /**
     * Retrieves a single item from the data table.
     *
     * @param key - The partition key and sort key
     * @returns The data model or undefined if not found
     */
    async getItem(key) {
        return await this.dynamoDbService.getItem(this.tableName, key);
    }
    /**
     * Lists items by partition key with optional filtering and pagination.
     *
     * @param pk - The partition key to query
     * @param opts - Optional query parameters
     * @param opts.sk - Sort key filter expression
     * @param opts.startFromSk - Start key for pagination
     * @param opts.limit - Maximum number of items to return
     * @param opts.order - Sort order ('asc' or 'desc')
     * @returns List of data entities with pagination info
     */
    async listItemsByPk(pk, opts) {
        const { lastSk, items } = await this.dynamoDbService.listItemsByPk(this.tableName, pk, opts?.sk, opts?.startFromSk, opts?.limit, opts?.order);
        return new interfaces_1.DataListEntity({
            lastSk,
            items: items.map((item) => new interfaces_1.DataEntity(item)),
        });
    }
};
exports.DataService = DataService;
exports.DataService = DataService = DataService_1 = __decorate([
    (0, common_1.Injectable)(),
    __param(0, (0, common_1.Inject)(command_module_definition_1.MODULE_OPTIONS_TOKEN)),
    __metadata("design:paramtypes", [Object, dynamodb_service_1.DynamoDbService])
], DataService);
//# sourceMappingURL=data.service.js.map