TypeScript JSON utils

json-utils.ts

import * as _ from 'lodash'
import * as objectPath from 'object-path'
import * as stringify from 'json-stringify-safe'

/**
 * Recursively replace undefined with null.
 */
export function undefinedToNull<T>(obj: T): T {
    if (obj === undefined) {
        return null
    }
    return replaceAllXWithY<undefined, null>(obj, (x) => x === undefined, () => null)
}

/**
 * Recursively replace objects with useful string conversions to strings.
 */
export function allToString(obj: any) {
    return replaceAllXWithY<{ toString?: () => string }, string>(
        obj,
        (x) => x && typeof x.toString === 'function' && !x.toString().startsWith('[object'),
        (x) => x.toString()
    )
}

/**
 * Generic recursive replacement.
 */
export function replaceAllXWithY<X, Y>(
    obj: any,
    identifyX: (x: X) => boolean,
    replaceWithY: (x: X) => Y
) {
    if (identifyX(obj)) {
        return replaceWithY(obj)
    }
    if (_.isArray(obj)) {
        return obj.map((item) => replaceAllXWithY(item, identifyX, replaceWithY))
    }
    if (_.isObject(obj)) {
        return Object.keys(obj).reduce((acc, key) => {
            acc[key] = replaceAllXWithY(obj[key], identifyX, replaceWithY)
            return acc
        }, {})
    }
    return obj
}

/**
 * List all of the possible paths through an object.
 */
export function enumeratePaths(value: any, separator: string = '.'): string[] {
    let paths: string[] = []
    if (value && typeof value === 'object') {
        paths = Object.getOwnPropertyNames(value)
        for (const key of Object.getOwnPropertyNames(value)) {
            paths = [
                ...paths,
                ...enumeratePaths(value[key]).map((subKey) => `${key}${separator}${subKey}`)
            ]
        }
    }
    return paths
}

/**
 * Turn e.g.
 *     { some: { nestedThing: { key: "value" } } }
 * into
 *     { some_nested_thing_key: "value" }
 */
export function flattenToParams<T = any>(obj: object): { [key: string]: T } {
    const deCycled = JSON.parse(stringify(obj))
    return enumeratePaths(deCycled, '.').reduce((flattened: { [key: string]: T }, path: string) => {
        const value = objectPath.get(obj, path)
        if (typeof value !== 'object') {
            const flatPath = _.snakeCase(path.replace('.', '_'))
            flattened[flatPath] = value
        }
        return flattened
    }, {})
}