How to flatten the output?

[nocquidant]

Hi, I'd like to flatten my JSON output (of course I have some exceptions).
How could I do such a thing?
Thanks!

{
name = "Swallow"
job {
  title = "Sr. Nest Maker"
  company = "Nests R Us"
  exception = {
    foo = "bar",
    foobar = "bar"
  }
}

=>

{
  "name": "Swallow",
  "job_title": "Sr. Nest Maker",
  "job_company": "Nests R Us",
  "job_exception": {
    "foo": "bar" 
    "foobar": "bar" 
   }
  }
}

[HT154]

Here's a function that will flatten a specific key in an object and return it as a Map:

function flattenKey(obj: Map|Mapping|Dynamic|Typed, key: String): Map =
  obj.toMap().remove(key) + (
    obj.toMap().getOrNull(key)?.toMap()?.mapKeys((k, _) -> "\(key)_\(k)") ?? Map()
  )

You can either call this directly as-needed or use renderer converters to apply the transformation at render time to the appropriate classes/paths.

[nocquidant]

Thanks that helps!
But how to get my pairs (obj,key) for rendering converters?

[HT154]

I think I need more info from you to answer that! Are you using modules/classes to define how to represent this data? (that's best practice in Pkl)

If you define classes you could do this:

// schema.pkl

name: String
job: Job

class Job {
  title: String
  company: String
  exception: JobException
}

class JobException {
  foo: String
  foobar: String
}

function flattenKey(obj: Map|Mapping|Dynamic|Typed, key: String): Map =
  obj.toMap().remove(key) + (
    obj.toMap().getOrNull(key)?.toMap()?.mapKeys((k, _) -> "\(key)_\(k)") ?? Map()
  )

output {
  renderer = new JsonRenderer {
    converters {
      [module.getClass()] = (it) -> flattenKey(it, "job")
    }
  }
}

Then usage:

// swallow.pkl
amends "schema.pkl"
name = "Swallow"
job {
  title = "Sr. Nest Maker"
  company = "Nests R Us"
  exception {
    foo = "bar"
    foobar = "bar"
  }
}

[HT154]

Here's another (probably over-engineered) way to go about this using annotations and reflection:

// schema.pkl
// I've expanded the types with some additional test cases
import "pkl:reflect"

name: String

@Flatten
job: Job

class Job {
	title: String
	company: String
	exception: JobException
	@Flatten
	nested: JobNested
	@Flatten
	nestedMapping: Mapping<String, Any>
	@Flatten
	nestedDynamic: Dynamic
}

class JobException {
	foo: String
	foobar: String
	@Flatten
	nested: JobNested
}

class JobNested {
	bar: String
	baz: String
}

class Flatten extends Annotation {}

function doFlatten(obj: Any): Any =
	if (obj is Typed)
		let (objClazz = reflect.Class(obj.getClass()))
			getProps(objClazz).flatMap((key, prop) ->
				if (prop.first.contains("hidden")) Map()
				else if (prop.second.contains(new Flatten {}))
					let (propVal = doFlatten(obj.getProperty(key)))
						if (propVal is Map) propVal.mapKeys((k, _) -> "\(key)_\(k)")
						else Map(key, propVal)
				else Map(key, obj.getProperty(key))
			)
	else if (obj is Map|Mapping|Dynamic) obj.toMap().mapValues((_, val) -> doFlatten(val))
	else if (obj is List|Listing) obj.toList().map((val) -> doFlatten(val))
	else obj

function getProps(clazz: reflect.Class): Map<String, Pair<Set<String>, List<Annotation>>> =
	if (clazz.superclass != null)
		let (parentProps = getProps(clazz.superclass!!))
			(parentProps.keys + clazz.properties.keys).toMap(
				(key) -> key,
				(key) -> if (parentProps.containsKey(key) && clazz.properties.containsKey(key))
					Pair(
						parentProps[key].first + clazz.properties[key].modifiers,
						parentProps[key].second + clazz.properties[key].annotations
					)
				else parentProps.getOrNull(key) ?? Pair(clazz.properties[key].modifiers, clazz.properties[key].annotations)
			)
	else clazz.properties.mapValues((_, prop) -> Pair(prop.modifiers, prop.annotations))

output {
	renderer = new JsonRenderer {
		converters {
			[Typed] = (it) -> doFlatten(it)
		}
	}
}

Then usage:

// swallow.pkl
amends "schema.pkl"
name = "Swallow"
job {
	title = "Sr. Nest Maker"
	company = "Nests R Us"
	exception {
		foo = "bar"
		foobar = "bar"
		nested {
			bar = "none"
			baz = "none"
		}
	}
	nested {
		bar = "baz"
		baz = "baz"
	}
	nestedMapping {
		["abc"] = 123
		["def"] = "ghi"
	}
	nestedDynamic {
		hello = "world"
		dynamicNest {
			good = "bye"
		}
	}
}

Result:

{
  "name": "Swallow",
  "job_title": "Sr. Nest Maker",
  "job_company": "Nests R Us",
  "job_exception": {
    "foo": "bar",
    "foobar": "bar",
    "nested": {
      "bar": "none",
      "baz": "none"
    }
  },
  "job_nested_bar": "baz",
  "job_nested_baz": "baz",
  "job_nestedMapping_abc": 123,
  "job_nestedMapping_def": "ghi",
  "job_nestedDynamic_hello": "world",
  "job_nestedDynamic_dynamicNest": {
    "good": "bye"
  }
}

It is worth noting that this likely breaks most (non-primitive) class-based converters. There's probably a way to resolve that, but that's an exercise left for the reader ;)

[nocquidant]

Thank you for the detailed answer!