From 5bedad30d38ab401b65a33bf165f5d5aaa644471 Mon Sep 17 00:00:00 2001 From: Bluebberies Date: Thu, 24 Oct 2024 00:25:45 +0100 Subject: [PATCH 1/2] Added tests to check for flatten call unhandled error --- test/unhandledExceptionsTest.js | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+) create mode 100644 test/unhandledExceptionsTest.js diff --git a/test/unhandledExceptionsTest.js b/test/unhandledExceptionsTest.js new file mode 100644 index 0000000..cc2cfb8 --- /dev/null +++ b/test/unhandledExceptionsTest.js @@ -0,0 +1,28 @@ +import assert from "node:assert"; +import { describe, test } from "node:test"; +import { flatten, unflatten } from "../index.js"; + +describe("flatten obj tests", function () { + test("Flatten null", function () { + assert.deepStrictEqual(flatten(null), null); + }); + + test("Flatten undefined", function () { + assert.deepStrictEqual(flatten(undefined), undefined); + }); + + test("Flatten object with Symbol keys", function () { + const sym = Symbol("test"); + const obj = { [sym]: "value", regularKey: "regularValue" }; + const flatObj = flatten(obj); + + assert.strictEqual(flatObj["Symbol(test)"], "value"); // Assuming stringification of symbol keys + }); + + test("Flatten circular reference", function () { + const obj = { name: "John" }; + obj.self = obj; // Circular reference + + assert.throws(() => flatten(obj), /Circular reference detected/); + }); +}); From ee78acdb6a8fbcd4e5e394deb3a73d8a7ae437e0 Mon Sep 17 00:00:00 2001 From: Bluebberies Date: Thu, 24 Oct 2024 08:53:09 +0100 Subject: [PATCH 2/2] Handled unhandled exceptions when flattening objects --- index.js | 199 +++++++++++++++++++++++++++++-------------------------- 1 file changed, 105 insertions(+), 94 deletions(-) diff --git a/index.js b/index.js index 42e1ddc..503b7b5 100644 --- a/index.js +++ b/index.js @@ -1,157 +1,168 @@ -function isBuffer (obj) { - return obj && +function isBuffer(obj) { + return ( + obj && obj.constructor && - (typeof obj.constructor.isBuffer === 'function') && + typeof obj.constructor.isBuffer === "function" && obj.constructor.isBuffer(obj) + ); } -function keyIdentity (key) { - return key +function keyIdentity(key) { + return key; } -export function flatten (target, opts) { - opts = opts || {} +export function flatten(target, opts) { + opts = opts || {}; - const delimiter = opts.delimiter || '.' - const maxDepth = opts.maxDepth - const transformKey = opts.transformKey || keyIdentity - const output = {} + if (target === null || target === undefined) { + return target; + } + + const delimiter = opts.delimiter || "."; + const maxDepth = opts.maxDepth; + const transformKey = opts.transformKey || keyIdentity; + const output = {}; + + const seenObjects = new WeakSet(); + + function step(object, prev, currentDepth) { + currentDepth = currentDepth || 1; + + if (seenObjects.has(object)) { + throw new Error("Circular reference detected"); + } + + seenObjects.add(object); - function step (object, prev, currentDepth) { - currentDepth = currentDepth || 1 Object.keys(object).forEach(function (key) { - const value = object[key] - const isarray = opts.safe && Array.isArray(value) - const type = Object.prototype.toString.call(value) - const isbuffer = isBuffer(value) - const isobject = ( - type === '[object Object]' || - type === '[object Array]' - ) + const value = object[key]; + const isarray = opts.safe && Array.isArray(value); + const type = Object.prototype.toString.call(value); + const isbuffer = isBuffer(value); + const isobject = type === "[object Object]" || type === "[object Array]"; const newKey = prev ? prev + delimiter + transformKey(key) - : transformKey(key) - - if (!isarray && !isbuffer && isobject && Object.keys(value).length && - (!opts.maxDepth || currentDepth < maxDepth)) { - return step(value, newKey, currentDepth + 1) + : transformKey(key); + + if ( + !isarray && + !isbuffer && + isobject && + Object.keys(value).length && + (!opts.maxDepth || currentDepth < maxDepth) + ) { + return step(value, newKey, currentDepth + 1); } - output[newKey] = value - }) + output[newKey] = value; + }); + + const symbols = Object.getOwnPropertySymbols(object); + symbols.forEach((symbol) => { + const value = object[symbol]; + const newKey = prev ? prev + delimiter + String(symbol) : String(symbol); + output[newKey] = value; + }); } - step(target) + step(target); - return output + return output; } -export function unflatten (target, opts) { - opts = opts || {} +export function unflatten(target, opts) { + opts = opts || {}; - const delimiter = opts.delimiter || '.' - const overwrite = opts.overwrite || false - const transformKey = opts.transformKey || keyIdentity - const result = {} + const delimiter = opts.delimiter || "."; + const overwrite = opts.overwrite || false; + const transformKey = opts.transformKey || keyIdentity; + const result = {}; - const isbuffer = isBuffer(target) - if (isbuffer || Object.prototype.toString.call(target) !== '[object Object]') { - return target + const isbuffer = isBuffer(target); + if ( + isbuffer || + Object.prototype.toString.call(target) !== "[object Object]" + ) { + return target; } // safely ensure that the key is // an integer. - function getkey (key) { - const parsedKey = Number(key) - - return ( - isNaN(parsedKey) || - key.indexOf('.') !== -1 || - opts.object - ) + function getkey(key) { + const parsedKey = Number(key); + + return isNaN(parsedKey) || key.indexOf(".") !== -1 || opts.object ? key - : parsedKey + : parsedKey; } - function addKeys (keyPrefix, recipient, target) { + function addKeys(keyPrefix, recipient, target) { return Object.keys(target).reduce(function (result, key) { - result[keyPrefix + delimiter + key] = target[key] + result[keyPrefix + delimiter + key] = target[key]; - return result - }, recipient) + return result; + }, recipient); } - function isEmpty (val) { - const type = Object.prototype.toString.call(val) - const isArray = type === '[object Array]' - const isObject = type === '[object Object]' + function isEmpty(val) { + const type = Object.prototype.toString.call(val); + const isArray = type === "[object Array]"; + const isObject = type === "[object Object]"; if (!val) { - return true + return true; } else if (isArray) { - return !val.length + return !val.length; } else if (isObject) { - return !Object.keys(val).length + return !Object.keys(val).length; } } target = Object.keys(target).reduce(function (result, key) { - const type = Object.prototype.toString.call(target[key]) - const isObject = (type === '[object Object]' || type === '[object Array]') + const type = Object.prototype.toString.call(target[key]); + const isObject = type === "[object Object]" || type === "[object Array]"; if (!isObject || isEmpty(target[key])) { - result[key] = target[key] - return result + result[key] = target[key]; + return result; } else { - return addKeys( - key, - result, - flatten(target[key], opts) - ) + return addKeys(key, result, flatten(target[key], opts)); } - }, {}) + }, {}); Object.keys(target).forEach(function (key) { - const split = key.split(delimiter).map(transformKey) - let key1 = getkey(split.shift()) - let key2 = getkey(split[0]) - let recipient = result + const split = key.split(delimiter).map(transformKey); + let key1 = getkey(split.shift()); + let key2 = getkey(split[0]); + let recipient = result; while (key2 !== undefined) { - if (key1 === '__proto__') { - return + if (key1 === "__proto__") { + return; } - const type = Object.prototype.toString.call(recipient[key1]) - const isobject = ( - type === '[object Object]' || - type === '[object Array]' - ) + const type = Object.prototype.toString.call(recipient[key1]); + const isobject = type === "[object Object]" || type === "[object Array]"; // do not write over falsey, non-undefined values if overwrite is false - if (!overwrite && !isobject && typeof recipient[key1] !== 'undefined') { - return + if (!overwrite && !isobject && typeof recipient[key1] !== "undefined") { + return; } if ((overwrite && !isobject) || (!overwrite && recipient[key1] == null)) { - recipient[key1] = ( - typeof key2 === 'number' && - !opts.object - ? [] - : {} - ) + recipient[key1] = typeof key2 === "number" && !opts.object ? [] : {}; } - recipient = recipient[key1] + recipient = recipient[key1]; if (split.length > 0) { - key1 = getkey(split.shift()) - key2 = getkey(split[0]) + key1 = getkey(split.shift()); + key2 = getkey(split[0]); } } // unflatten again for 'messy objects' - recipient[key1] = unflatten(target[key], opts) - }) + recipient[key1] = unflatten(target[key], opts); + }); - return result + return result; }