sk: createDelimitedAttribute()

in source/packages/services/events-processor/src/api/events/event.dao.ts [94:199]
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({