如何使用我的 Typescript 解析器对这个 Graphql 数组进行排序？

Question

I'm trying to get my filter to return my array of objects in descending order according to 'price' when sortPrice === true.

I'm using 'type-graphql' for my resolver and the package 'fast-sort' to sort the data in descending order.

here is my resolver code - note that the price filter works as intended.

 // Price filter if (minPrice) { filteredItems = filteredItems.filter((item: any) => item.price >= minPrice); } if (maxPrice) { filteredItems = filteredItems.filter((item: any) => item.price <= maxPrice); } // Sort price/rating if (sortPrice) { filteredItems = filteredItems.filter((item: any) => sort(items).desc()); }

here is my graphql playground query - you can see it is not sorting the array by the price.

Answer 1

As far as I'm concerned, i'm using this piece of code to sort an array of objects. Can be sorted in by ASC/DESC, and by one or several keys. I found this function here in stackoverflow few weeks later, that I have adjusted a little bit. Have also create an enum to make the code more safe. This is in typescript but you can get rid off the types and interface to convert in Javascript

export declare enum EOrderBy {
    ASC = "ASC",
    DESC = "DESC"
}

export interface ISortConfig<T> {
    column: keyof T;
    order?: keyof typeof EOrderBy;
    map?: itemMap;
}

export const sortByValues = <T extends object>(
    columns: (keyof T | ISortConfig<T>)[]
): ((a: T, b: T) => 0 | 1 | -1) => {
    return function (a: T, b: T) {
        const firstKey: keyof T | ISortConfig<T> = columns[0];
        const isSimple = typeof firstKey === "string";
        const key: keyof T = isSimple
            ? (firstKey as keyof T)
            : (firstKey as ISortConfig<T>).column;
        const reverse: boolean = isSimple
            ? false
            : (firstKey as ISortConfig<T>).order
            ? (firstKey as ISortConfig<T>).order?.toUpperCase() === "ASC"
                ? false
                : true
            : false;
        const map: itemMap | null = isSimple
            ? null
            : (firstKey as ISortConfig<T>).map || null;

        const valA = map ? map(a[key]) : a[key];
        const valB = map ? map(b[key]) : b[key];
        if (valA === valB) {
            if (columns.length === 1) {
                return 0;
            }
            return sortByValues<T>(columns.slice(1))(a, b);
        }
        if (reverse) {
            return valA > valB ? -1 : 1;
        }
        return valA > valB ? 1 : -1;
    };
};

export const sortArray = <T extends object>(
    array: T[],
    columns: (keyof T | ISortConfig<T>)[]
) => {
    return array.sort(sortByValues<T>(columns));
};

example of usage:

interface IObj {
    name: string;
    prenom: string;
    montant: number;
}

const arrobj: IObj[] = [
    {
        name: "al",
        prenom: "jero",
        montant: 10,
    },
    {
        name: "al",
        prenom: "ale",
        montant: 100,
    },
    {
        name: "zozo",
        prenom: "aa",
        montant: 10,
    },
];

//simple order 
console.log(sortArray(arrobj, [{ column: "prenom", order: "ASC" }]));
console.log(sortArray(arrobj, [{ column: "montant", order: "DESC" }]));


//order by several properties (montant DESC then name ASC)
console.log(
    sortArray(arrobj, [
        { column: "montant", order: "DESC" },
        { column: "name", order: "ASC" },
    ])
);

// preparing the orderBy parameter in a variable then send it to the function
const orderBy: IOrderBy<IObj>[] = [
    { column: "name", order: EOrderBy.DESC },
    { column: "prenom", order: EOrderBy.DESC },
];

console.log(sortArray(arrobj, orderBy));