If you need to process nested objects in JavaScript, you can utilize a function like the one provided below:

data = require("./data.json")

flattenObject = (obj) => {
    let flattenKeys = {};
    for (let i in obj) {
        if (!obj.hasOwnProperty(i)) continue;
        if ((typeof obj[i]) == 'object') {
            let flatObject = flattenObject(obj[i]);
            for (let j in flatObject) {
                if (!flatObject.hasOwnProperty(j)) continue;
                flattenKeys[i + '.' + j] = flatObject[j];
            }
        } else {
            flattenKeys[i] = obj[i];
        }
    }
    return flattenKeys;
}

console.log(flattenObject(data))

The resulting flattened object derived from your array's first element is displayed below:

{ countyCode: 12,
  'customer.addresses.0.addressType': 'R',
  'customer.addresses.0.city': 'BRADENTON',
  'customer.addresses.0.countryCode': 'US',
  'customer.addresses.0.countyCode': 12,
  'customer.addresses.0.state': 'FL',
  'customer.addresses.0.streetAddress': '819 15th Ave Dr E',
  'customer.addresses.0.zipCode': 34211,
  'customer.addresses.1.addressType': 'M',
  'customer.addresses.1.city': 'BRADENTON',
  'customer.addresses.1.countryCode': 'US',
  'customer.addresses.1.countyCode': 12,
  'customer.addresses.1.state': 'FL',
  'customer.addresses.1.streetAddress': 'PO BOX 124',
  'customer.addresses.1.zipCode': 34201,
  'customer.addresses.1.zipPlus': '124',
  'customer.customerNumber': 932874,
  'customer.customerStopFlag': false,
  'customer.customerType': 'I',
  'customer.dateOfBirth': '1936-08-05T00:00:00',
  'customer.dlExpirationDate': '2022-08-05T00:00:00',
  'customer.dlRenewalEligibilityFlag': true,
  'customer.driverLicenseNumber': 'B360722339284',
  'customer.firstName': 'David',
  'customer.lastName': 'Brierton',
  'customer.middleName': 'Hugh',
  'customer.sex': 'M' }

Here's an alternate approach:

function convertObjectToString(obj) {
    var path = [],
        nodes = {},
        parseObj = function (obj) {
            if (typeof obj == 'object') {
                if (obj instanceof Array) { //array
                    for (var i = 0, l = obj.length; i < l; i++) {
                        path.push(i);
                        parseObj(obj[i]);
                        path.pop();
                    }
                }
                else {  //object
                    for (var node in obj) {
                        path.push(node);
                        parseObj(obj[node]);
                        path.pop();
                    }
                }
            }
            else {  //value
                nodes[path.join('_')] = obj;
            }
        };

    parseObj(obj);
    return nodes;
}

console.log(JSON.stringify(convertObjectToString(data)));

• I utilized a global path array to streamline the recursive path and reduce unnecessary string operations
• I took into consideration the potential size of JSON files to ensure efficiency
• In this specific case, there is no requirement to check for "hasOwnProperty"

If you're looking for an efficient solution, I suggest utilizing the flat package instead of creating a new one from scratch. If you prefer to explore existing code, you can refer to Hugh's implementation found here. He covers both flatten and unflatten functionalities. Here is a snippet of the flatten function:

var isBuffer = require('is-buffer')

module.exports = flatten
flatten.flatten = flatten
flatten.unflatten = unflatten

function flatten (target, opts) {
  opts = opts || {}

  var delimiter = opts.delimiter || '.'
  var maxDepth = opts.maxDepth
  var output = {}

  function step (object, prev, currentDepth) {
    currentDepth = currentDepth || 1
    Object.keys(object).forEach(function (key) {
      var value = object[key]
      var isarray = opts.safe && Array.isArray(value)
      var type = Object.prototype.toString.call(value)
      var isbuffer = isBuffer(value)
      var isobject = (
        type === '[object Object]' ||
        type === '[object Array]'
      )

      var newKey = prev
        ? prev + delimiter + key
        : key

      if (!isarray && !isbuffer && isobject && Object.keys(value).length &&
        (!opts.maxDepth || currentDepth < maxDepth)) {
        return step(value, newKey, currentDepth + 1)
      }

      output[newKey] = value
    })
  }

  step(target)

  return output
}

Provided below is a solution that ensures readability and accurately parses dates in addition to flattening objects recursively. While several solutions flatten objects recursively, they often overlook the fact that dates are also objects. This oversight may not be an issue when working with JSON files as mentioned by OP, but using the same flattener-function on JavaScript objects could lead to incorrect parsing of dates.

The 'flatten' function inserts one or more prefixes if necessary (e.g., "my.prefixes.here.0.value")

export const flatten = (obj, prefix = [], current = {}) => {
  const isDate = obj instanceof Date;
  const isObject = typeof obj === "object";
  const notNull = obj !== null;
  const flattenRecursive = !isDate && isObject && notNull;

  if (flattenRecursive) {
    for (const key in obj) {
      flatten(obj[key], prefix.concat(key), current);
    }
  } else {
    current[prefix.join(".")] = obj;
  }
  return current;
};

Edit: Output from the function applied to example data provided by OP:

{ '0.countyCode': 12,
  '0.customer.addresses.0.addressType': 'R',
  '0.customer.addresses.0.city': 'BRADENTON',
  '0.customer.addresses.0.countryCode': 'US',
  '0.customer.addresses.0.countyCode': 12,
  '0.customer.addresses.0.foreignPostalCode': null,
  '0.customer.addresses.0.state': 'FL',
  '0.customer.addresses.0.streetAddress': '819 15th Ave Dr E',
  '0.customer.addresses.0.zipCode': 34211,
  '0.customer.addresses.0.zipPlus': null,
  '0.customer.addresses.1.addressType': 'M',
  '0.customer.addresses.1.city': 'BRADENTON',
  '0.customer.addresses.1.countryCode': 'US',
  '0.customer.addresses.1.countyCode': 12,
  '0.customer.addresses.1.foreignPostalCode': null,
  '0.customer.addresses.1.state': 'FL',
  '0.customer.addresses.1.streetAddress': 'PO BOX 124',
  '0.customer.addresses.1.zipCode': 34201,
  '0.customer.addresses.1.zipPlus': '0124',
  '0.customer.companyName': null,
  '0.customer.customerNumber': 932874,
  '0.customer.customerStopFlag': false,
  '0.customer.customerType': 'I',
  '0.customer.dateOfBirth': '1936-08-05T00:00:00',
  '0.customer.dlExpirationDate': '2022-08-05T00:00:00',
  '0.customer.dlRenewalEligibilityFlag': true,
  '0.customer.driverLicenseNumber': 'B360722339284',
  '0.customer.emailAddress': null,
  '0.customer.feidNumber': null,
  '0.customer.firstName': 'David',
  '0.customer.lastName': 'Brierton',
  '0.customer.middleName': 'Hugh',
  '0.customer.militaryExemptionFlag': null,
  '0.customer.nameSuffix': null,
  '0.customer.sex': 'M' }

function convertObjToCsv(obj, options) {
        if (typeof obj !== 'object') return null;
        options = options || {};
        var scopechar = options.scopechar || '.';
        var delimiter = options.delimiter || ',';
        if (!Array.isArray(obj)) obj = [obj];
        var current, name, rowNumber, key, queue, values = [], rows = [], headers = {}, headersArr = [];
        for (rowNumber = 0; rowNumber < obj.length; rowNumber++) {
            queue = [obj[rowNumber], ''];
            rows[rowNumber] = {};
            while (queue.length > 0) {
                name = queue.pop();
                current = queue.pop();
                if (current !== null && typeof current === 'object') {
                    for (key in current) {
                        if (current.hasOwnProperty(key)) {
                            queue.push(current[key]);
                            queue.push(name + (name ? scopechar : '') + key);
                        }
                    }
                } else {
                    if (headers[name] === undefined) headers[name] = true;
                    rows[rowNumber][name] = current;
                }
            }
            values[rowNumber] = [];
        }
        // create csv text
        for (key in headers) {
            if (headers.hasOwnProperty(key)) {
                headersArr.push(key);
                for (rowNumber = 0; rowNumber < obj.length; rowNumber++) {
                    values[rowNumber].push(rows[rowNumber][key] === undefined
                                        ? ''
                                        : rows[rowNumber][key]);
                }
            }
        }
        for (rowNumber = 0; rowNumber < obj.length; rowNumber++) {
            values[rowNumber] = values[rowNumber].join(delimiter);

        }

          return '"' + headersArr.join('"' + delimiter + '"') + '"\n' + values.join('\n');
    }

If you have a JSON object similar to the following:

{
  "_id": "template:user",
  "_rev": "11-d319c4ac632171d6f01c40fdef3164a5",
  "p": "user",
  "first_name": "first_name_000",
  "last_name": "last_name_000",
  "favorite_list": {
    "field": "value_000"
  },
  "list_kmorganisation": [
    {
      "siren": "siren_000",
      "partition": "partition_000",
      "id_role": "id_role_000",
      "is_default": "is_default_000",
      "is_managed": "is_managed_000",
      "is_banned": "is_managed_000",
      "ban_reason": "ban_reason_000",
      "ban_date": "ban_date_000",
      "last_connection": "last_connection_000"
    }
  ],
  "login": {
    "mail": "mail_000",
    "passwd": "passwd_000",
    "salt": "salt_000",
    "status": "status_000",
    "access": [
      {
        "log_date": "log_date_000",
        "os": "os_000",
        "version": "version_000",
        "ip_addr": "ip_addr_000",
        "screen": "screen_000"
      }
    ]
  }
}

The flattened output will be as follows: "login__access__0__screen", "login__access__0__ip_addr", "login__access__0__version", "login__access__0__os", "login__access__0__log_date", "login__status", "login__salt", "login__passwd", "login__mail", "last_name","first_name", "list_kmorganisation__1__last_connection", "list_kmorganisation__1__ban_date", ...truncated for brevity... "p", "_rev", "_id" (All in one line with corresponding values on the next line)