RocketChat/Rocket.Chat

import { BSONType } from './types';

export const getBSONType = <T>(v: T): BSONType => {
    if (typeof v === 'number') {
        return BSONType.Double;
    }

    if (typeof v === 'string') {
        return BSONType.String;
    }

    if (typeof v === 'boolean') {
        return BSONType.Boolean;
    }

    if (Array.isArray(v)) {
        return BSONType.Array;
    }

    if (v === null) {
        return BSONType.Null;
    }

    if (v instanceof RegExp) {
        return BSONType.Regex;
    }

    if (typeof v === 'function') {
        return BSONType.JavaScript;
    }

    if (v instanceof Date) {
        return BSONType.Date;
    }

    if (v instanceof Uint8Array) {
        return BSONType.BinData;
    }

    return BSONType.Object;
};

const getBSONTypeOrder = (type: BSONType): number => {
    switch (type) {
        case BSONType.Null:
            return 0;

        case BSONType.Double:
        case BSONType.Int:
        case BSONType.Long:
            return 1;

        case BSONType.String:
        case BSONType.Symbol:
            return 2;

        case BSONType.Object:
            return 3;

        case BSONType.Array:
            return 4;

        case BSONType.BinData:
            return 5;

        case BSONType.ObjectId:
            return 6;

        case BSONType.Boolean:
            return 7;

        case BSONType.Date:
        case BSONType.Timestamp:
            return 8;

        case BSONType.Regex:
            return 9;

        case BSONType.JavaScript:
        case BSONType.JavaScriptWithScope:
            return 100;

        default:
            return -1;
    }
};

type ObjectID = {
    toHexString(): string;
    equals(otherID: ObjectID): boolean;
};

export const compareBSONValues = (a: unknown, b: unknown): number => {
    if (a === undefined) {
        return b === undefined ? 0 : -1;
    }

    if (b === undefined) {
        return 1;
    }

    const ta = getBSONType(a);
    const oa = getBSONTypeOrder(ta);

    const tb = getBSONType(b);
    const ob = getBSONTypeOrder(tb);

    if (oa !== ob) {
        return oa < ob ? -1 : 1;
    }

    if (ta !== tb) {
        throw Error('Missing type coercion logic in compareBSONValues');
    }

    switch (ta) {
        case BSONType.Double:
            return (a as number) - (b as number);

        case BSONType.String:
            return (a as string).localeCompare(b as string);

        case BSONType.Object:
            return compareBSONValues(
                Array.prototype.concat.call([], ...Object.entries(a as Record<string, unknown>)),
                Array.prototype.concat.call([], ...Object.entries(b as Record<string, unknown>)),
            );

        case BSONType.Array: {
            for (let i = 0; ; i++) {
                if (i === (a as unknown[]).length) {
                    return i === (b as unknown[]).length ? 0 : -1;
                }

                if (i === (b as unknown[]).length) {
                    return 1;
                }

                const s = compareBSONValues((a as unknown[])[i], (b as unknown[])[i]);
                if (s !== 0) {
                    return s;
                }
            }
        }

        case BSONType.BinData: {
            if ((a as Uint8Array).length !== (b as Uint8Array).length) {
                return (a as Uint8Array).length - (b as Uint8Array).length;
            }

            for (let i = 0; i < (a as Uint8Array).length; i++) {
                if ((a as Uint8Array)[i] === (b as Uint8Array)[i]) {
                    continue;
                }

                return (a as Uint8Array)[i] < (b as Uint8Array)[i] ? -1 : 1;
            }

            return 0;
        }

        case BSONType.Null:
        case BSONType.Undefined:
            return 0;

        case BSONType.ObjectId:
            return (a as ObjectID).toHexString().localeCompare((b as ObjectID).toHexString());

        case BSONType.Boolean:
            return Number(a) - Number(b);

        case BSONType.Date:
            return (a as Date).getTime() - (b as Date).getTime();

        case BSONType.Regex:
            throw Error('Sorting not supported on regular expression');

        case BSONType.JavaScript:
        case BSONType.JavaScriptWithScope:
            throw Error('Sorting not supported on Javascript code');
    }

    throw Error('Unknown type to sort');
};