How to use the tubular-common.AggregateFunctions.Sum function in tubular-common

const results = _.map(aggregateColumns, column => {
        let value;
        switch (column.aggregate) {
            case AggregateFunctions.Sum:
                value = _.sumBy(subset, column.name);
                break;
            case AggregateFunctions.Average:
                value = _.meanBy(subset, column.name);
                break;
            case AggregateFunctions.Max:
                // .maxBy returns the object containing the max value
                value = _.maxBy(subset, column.name)[column.name];
                break;
            case AggregateFunctions.Min:
                // .minBy returns the object containing the min value
                value = _.minBy(subset, column.name)[column.name];
                break;
            case AggregateFunctions.Count:
                value = subset.length;
                break;

return Promise.all(_.map(aggregateColumns, column => {
        // Do not disrupt the original query chain
        let copyOfSubset = subset.clone();

        // in order to work with aggregates
        copyOfSubset.clearSelect();

        switch (column.aggregate) {
            case AggregateFunctions.Sum:
                copyOfSubset = copyOfSubset.sum(`${column.name} as tbResult`);
                break;
            case AggregateFunctions.Average:
                copyOfSubset = copyOfSubset.avg(`${column.name} as tbResult`);
                break;
            case AggregateFunctions.Max:
                copyOfSubset = copyOfSubset.max(`${column.name} as tbResult`);
                break;
            case AggregateFunctions.Min:
                copyOfSubset = copyOfSubset.min(`${column.name} as tbResult`);
                break;
            case AggregateFunctions.Count:
                copyOfSubset = copyOfSubset.count(`${column.name} as tbResult`);
                break;
            case AggregateFunctions.DistinctCount:
                copyOfSubset = copyOfSubset.countDistinct(`${column.name} as tbResult`);

it("uses Sum", done => {
            const take = 10,
                filteredCount = totalRecordCount;

            let request = new GridRequest([
                {
                    name: 'first_name', label: 'First Name', sortable: true, searchable: true, sortOrder: 2, sortDirection: 'Ascending'
                },
                {
                    name: 'last_name', label: 'Last Name', sortable: true, searchable: true, sortOrder: 3, sortDirection: 'Ascending'
                },
                {
                    name: 'address_id', label: 'Address Id', sortable: true, searchable: false, aggregate: AggregateFunctions.Sum
                }
            ],
                take,
                0,
            );

            let queryBuilder = knex.select('first_name', 'last_name', 'address_id', 'customer_id').from('customer');

            tubular.createGridResponse(request, queryBuilder)
                .then(response => {
                    expect(response.counter).toBeDefined();
                    expect(response.totalRecordCount).toBe(totalRecordCount);
                    expect(response.filteredRecordCount).toBe(filteredCount);
                    expect(response.totalPages).toBe(Math.ceil(filteredCount / take));
                    expect(response.payload.length).toBe(take);
                    expect(response.aggregationPayload).toBeDefined();

let queryBuilder = knex.select('customer_id', 'amount', 'payment_id').from('payment');


            let request = new GridRequest(
                [
                    {
                        name: 'customer_id', label: 'Customer Id', sortable: true, searchable: true, filter: {
                            name: '',
                            text: 1,
                            argument: [],
                            operator: CompareOperators.Equals,
                            hasFilter: false
                        }
                    },
                    {
                        name: 'amount', label: 'Amount', sortable: true, searchable: true, aggregate: AggregateFunctions.Sum
                    },
                    {
                        name: 'payment_id', label: 'Payment Id', sortable: true, searchable: false
                    }
                ],
                take,
                0,
            );

            tubular.createGridResponse(request, queryBuilder)
                .then(response => {

                    expect(response.counter).toBeDefined();
                    expect(response.totalRecordCount).toBe(totalRecordCount);
                    expect(response.filteredRecordCount).toBe(filteredCount);
                    expect(response.totalPages).toBe(Math.ceil(filteredCount / take));