src/utils/objects.ts

/*
 * This file is part of SudoBot.
 *
 * Copyright (C) 2021-2023 OSN Developers.
 *
 * SudoBot is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * SudoBot is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with SudoBot. If not, see <https://www.gnu.org/licenses/>.
 */

type AccessOptions = {
    noCreate?: boolean;
    noModify?: boolean;
    noArrayAccess?: boolean;
    returnExists?: boolean;
};

const access = (object: object | unknown[], accessor: string, setter?: (value: unknown) => unknown, options?: AccessOptions) => {
    const accessors = accessor.split(".");
    let current: unknown = object;
    let prevAccessor: string | undefined;

    if (accessors.length === 0 || !accessor) {
        return object;
    }

    for (const access of accessors) {
        const last = access === accessors[accessors.length - 1];

        if (current instanceof Object) {
            if (!options?.noArrayAccess && /\[\d+\]$/.test(access)) {
                const array = current[access.slice(0, access.indexOf("[")) as keyof typeof current] as unknown as Array<unknown>;

                if (!Array.isArray(array)) {
                    throw new Error(`Cannot access index ${access} of non-array value (${prevAccessor ?? "root"})`);
                }

                const index = parseInt(access.match(/\d+/)![0]);

                if (Number.isNaN(index)) {
                    throw new Error(`Invalid index ${index} (${prevAccessor ?? "root"})`);
                }

                current = array[index];

                if (options?.returnExists && last) {
                    return index in array;
                }

                if (setter && last && (!options?.noModify || !(index in array)) && (!options?.noCreate || index < array.length)) {
                    array[index] = setter(current);
                }
            } else {
                if (Array.isArray(current)) {
                    return options?.returnExists ? false : undefined;
                }

                const value = current[access as keyof typeof current];

                if (options?.returnExists && last) {
                    return access in current;
                }

                if (setter && last && (!options?.noModify || !(access in current)) && (!options?.noCreate || access in current)) {
                    (current as Record<PropertyKey, unknown>)[access as PropertyKey] = setter(current);
                }

                current = value;
            }
        } else {
            if (last) {
                return options?.returnExists ? false : undefined;
            }

            return current;
        }
    }

    return options?.returnExists ? true : current;
};

export const get = <V = unknown>(object: object | unknown[], accessor: string, options?: AccessOptions) =>
    access(object, accessor, undefined, options) as V;
export const has = (object: object | unknown[], accessor: string, options?: AccessOptions) =>
    access(object, accessor, undefined, { ...options, returnExists: true });
export const set = (object: object | unknown[], accessor: string, value: unknown, options?: AccessOptions) =>
    access(object, accessor, () => value, options);

export const toDotted = (object: Record<string, unknown>, arrayAccess = false) => {
    const result: Record<string, unknown> = {};

    function recurse(current: Record<string, unknown>, path: string[] = []) {
        for (const key in current) {
            if (current[key] instanceof Object && (arrayAccess || !Array.isArray(current[key]))) {
                recurse(current[key] as Record<string, unknown>, path.concat(key));
            } else {
                result[path.concat(key).join(".")] = current[key];
            }
        }
    }

    recurse(object);
    return result;
};
1	/*
2	* This file is part of SudoBot.
3	*
4	* Copyright (C) 2021-2023 OSN Developers.
5	*
6	* SudoBot is free software; you can redistribute it and/or modify it
7	* under the terms of the GNU Affero General Public License as published by
8	* the Free Software Foundation, either version 3 of the License, or
9	* (at your option) any later version.
10	*
11	* SudoBot is distributed in the hope that it will be useful, but
12	* WITHOUT ANY WARRANTY; without even the implied warranty of
13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	* GNU Affero General Public License for more details.
15	*
16	* You should have received a copy of the GNU Affero General Public License
17	* along with SudoBot. If not, see <https://www.gnu.org/licenses/>.
18	*/
19
20	type AccessOptions = {
21	noCreate?: boolean;
22	noModify?: boolean;
23	noArrayAccess?: boolean;
24	returnExists?: boolean;
25	};
26
27	const access = (object: object \| unknown[], accessor: string, setter?: (value: unknown) => unknown, options?: AccessOptions) => {
28	const accessors = accessor.split(".");
29	let current: unknown = object;
30	let prevAccessor: string \| undefined;
31
32	if (accessors.length === 0 \|\| !accessor) {
33	return object;
34	}
35
36	for (const access of accessors) {
37	const last = access === accessors[accessors.length - 1];
38
39	if (current instanceof Object) {
40	if (!options?.noArrayAccess && /\[\d+\]$/.test(access)) {
41	const array = current[access.slice(0, access.indexOf("[")) as keyof typeof current] as unknown as Array<unknown>;
42
43	if (!Array.isArray(array)) {
44	throw new Error(`Cannot access index ${access} of non-array value (${prevAccessor ?? "root"})`);
45	}
46
47	const index = parseInt(access.match(/\d+/)![0]);
48
49	if (Number.isNaN(index)) {
50	throw new Error(`Invalid index ${index} (${prevAccessor ?? "root"})`);
51	}
52
53	current = array[index];
54
55	if (options?.returnExists && last) {
56	return index in array;
57	}
58
59	if (setter && last && (!options?.noModify \|\| !(index in array)) && (!options?.noCreate \|\| index < array.length)) {
60	array[index] = setter(current);
61	}
62	} else {
63	if (Array.isArray(current)) {
64	return options?.returnExists ? false : undefined;
65	}
66
67	const value = current[access as keyof typeof current];
68
69	if (options?.returnExists && last) {
70	return access in current;
71	}
72
73	if (setter && last && (!options?.noModify \|\| !(access in current)) && (!options?.noCreate \|\| access in current)) {
74	(current as Record<PropertyKey, unknown>)[access as PropertyKey] = setter(current);
75	}
76
77	current = value;
78	}
79	} else {
80	if (last) {
81	return options?.returnExists ? false : undefined;
82	}
83
84	return current;
85	}
86	}
87
88	return options?.returnExists ? true : current;
89	};
90
91	export const get = <V = unknown>(object: object \| unknown[], accessor: string, options?: AccessOptions) =>
92	access(object, accessor, undefined, options) as V;
93	export const has = (object: object \| unknown[], accessor: string, options?: AccessOptions) =>
94	access(object, accessor, undefined, { ...options, returnExists: true });
95	export const set = (object: object \| unknown[], accessor: string, value: unknown, options?: AccessOptions) =>
96	access(object, accessor, () => value, options);
97
98	export const toDotted = (object: Record<string, unknown>, arrayAccess = false) => {
99	const result: Record<string, unknown> = {};
100
101	function recurse(current: Record<string, unknown>, path: string[] = []) {
102	for (const key in current) {
103	if (current[key] instanceof Object && (arrayAccess \|\| !Array.isArray(current[key]))) {
104	recurse(current[key] as Record<string, unknown>, path.concat(key));
105	} else {
106	result[path.concat(key).join(".")] = current[key];
107	}
108	}
109	}
110
111	recurse(object);
112	return result;
113	};