sk: createDelimitedAttribute()

in source/packages/services/events-processor/src/api/events/event.dao.ts [83:189]
83 lines of code
8 McCabe index (conditional complexity)

                    sk: createDelimitedAttribute(PkType.Type, PkType.Event),
                    name: item.name,
                    gsi1Sort: createDelimitedAttribute(PkType.Event, item.enabled, item.id),
                }
            }
        };

        params.RequestItems[this.eventConfigTable]=[eventCreate, typeCreate];

        const result = await this.dynamoDbUtils.batchWriteAll(params);
        if (this.dynamoDbUtils.hasUnprocessedItems(result)) {
            throw new Error('CREATE_EVENT_FAILED');
        }

        logger.debug(`event.dao save: exit:`);
    }

    public async get(eventId:string): Promise<EventItem> {
        logger.debug(`event.dao get: in: eventId:${eventId}`);

        ow(eventId, ow.string.nonEmpty);

        const params:DocumentClient.QueryInput = {
            TableName: this.eventConfigTable,
            IndexName: this.eventConfigGSI1,
            KeyConditionExpression: `#sk = :sk AND begins_with( #gsi1Sort, :gsi1Sort )`,
            ExpressionAttributeNames: {
                '#sk': 'sk',
                '#gsi1Sort': 'gsi1Sort'
            },
            ExpressionAttributeValues: {
                ':sk': createDelimitedAttribute(PkType.Event, eventId),
                ':gsi1Sort': createDelimitedAttributePrefix(PkType.Event, eventId)
            }
        };

        const results = await this._cachedDc.query(params).promise();
        if (results.Items===undefined || results.Items.length===0) {
            logger.debug('event.dao get: exit: undefined');
            return undefined;
        }

        const events = this.assemble(results.Items);

        logger.debug(`event.dao get: exit: response:${JSON.stringify(events[eventId])}`);
        return events[eventId];
    }

    private assemble(results:AWS.DynamoDB.DocumentClient.ItemList) : EventItemMap {
        logger.debug(`event.dao assemble: items: ${JSON.stringify(results)}`);

        const events:EventItemMap= {};
        for(const i of results) {

            const eventId=expandDelimitedAttribute(i.sk)[1];

            const event:EventItem = {
                id: eventId,
                eventSourceId: expandDelimitedAttribute(i.pk)[1],
                name: i.name,
                principal: i.principal,
                conditions: i.conditions,
                ruleParameters: i.ruleParameters,
                enabled: i.enabled,
                templates: i.templates,
                supportedTargets: i.supportedTargets,
                templateProperties: i.templateProperties,
                disableAlertThreshold: i.disableAlertThreshold
            } ;

            events[eventId] = event;
        }

        logger.debug(`event.dao assemble: exit: ${JSON.stringify(events)}`);
        return events;
    }

    public async delete(eventId:string): Promise<void> {
        logger.debug(`event.dao delete: in: eventId:${eventId}`);

        ow(eventId, ow.string.nonEmpty);

        // start to build up delete requests
        const deleteParams:DocumentClient.BatchWriteItemInput = {
            RequestItems: {}
        };
        deleteParams.RequestItems[this.eventConfigTable]=[];

        // find the event source record to be deleted
        const findByGSIParams:DocumentClient.QueryInput = {
            TableName: this.eventConfigTable,
            IndexName: this.eventConfigGSI1,
            KeyConditionExpression: `#sk=:sk`,
            ExpressionAttributeNames: {
                '#sk': 'sk'
            },
            ExpressionAttributeValues: {
                ':sk': createDelimitedAttribute(PkType.Event, eventId)
            }
        };

        const results = await this._cachedDc.query(findByGSIParams).promise();

        // if found, add to the list to be deleted
        if (results.Items!==undefined && results.Items.length>0) {
            for (const item of results.Items) {
                deleteParams.RequestItems[this.eventConfigTable].push({