Is it possible to recursively apply an enriching cue?

[magick93]

I'm successfully using cue to enrich. The cue file I"m using is below.

The enriching is mostly being applied to #Properties, but on the top level. I have a nested occurrences of the same schema. And I'm wondering how I can apply the same enrichment to properties deeper in the schema tree.

For example see the nested occurrences of properties here- https://gist.github.com/magick93/4e0bc58d7fb93142eeb6422c83d1f5ee#file-publicationtype-json-cue-L95-L104

Enrich Cue file

version:     string
title:       string
description?: string
required?: [...string]

#Property: {
	name?:        string
	description?: string	
	type?:       string // restrict with disjunction if desired
    table: title
	postgresDateType?: string
	notnull?:   bool
	properties?:  {
		[pName=string]: #TypeEnricher
		}
	items?: {
		$schema?: string
		required?: [...string]
		allOf?: [...{#Property}]
		type?: string
		title?:       string
		version?:     string
		description?: string
		enumNames?: [...string]
		enum?: [...string]
		minProperties?: number
		links?: [...{
			rel?: string
			href: string
			method?: string
			encType?: string
			schema?: {
				$schema?: string
				title?: string
				version?: string
				type?: string
				description?: string
				required?: [...string]
				properties?: {
					[pName=string]: #Property 
				}
			}
		}]
		definitions?: {
			[pName=string]: #Property 
		}
		properties?:  {
			[pName=string]: #TypeEnricher
		}
	}
	// items?: 	{
	// 	properties?: {#Property}
	// 	allOf?: [...{#Property}]
	// 	type?: string
	// 	items?: {}
	// 	$schema?: string
	// 	version?: string
	// 	title?: string
	// 	required?: [...string]
	// 	description?: string
	// 	minProperties?: number
	// }
	

	... // open to allow any additonal fields
}

allOf?: [...{#Property}]
properties: [pName=string]: 	#Property & { name: pName }
// properties: [required?=bool]: 	#Property & { required: required }
// properties: [table=string]: #Property & { table: title }

// properties: [required?=string]: #Property & {for _, v in required {
//                 (v): required: true
//         }
// 		}

properties: [string]: #TypeEnricher
#TypeEnricher: T={
	// required?: [string]
	#Property// embed proprty def
	if T.type != _|_ {
		psqlType: json2psql[T.type]
	}
	// #Property
	if T.title != _|_ {
		for k, v in hrxmlDateTypes {
			if T.title == k{
				postgresDateType: hrxmlDateTypes[T.title]
			}
		}
	}

	// if T.items != _|_ {
	// 	if T.items.properties != _|_ {
	// 		for k, v in T.items.properties {
	// 			if v.type == "string" {
	// 				k.psqlType: "text"
	// 			}
	// 		}
	// 	}
	// }
	// 	postgresDateType: hrxmlDateTypes[T.title]
	// } 
	if 	required != _|_ {
	for _, v in required {
		if T.name != _|_ {
			if T.name == v {
					notnull: true
				}
			}
		}
	}
	
	
}

// for _, v in required {
//     (v): required: true
// }
		

json2psql: {
	"number":  "int4"
	"integer": "int4"
	"boolean": "bool"
    "string":  "text"
	"object":  "jsonb"
	"array":   "jsonb"
}

hrxmlDateTypes: {
	"DateType": "date"
	"DatePeriodType": "tsrange"
	"DateTimePeriodType": "tsrange"
	"DateOpenEndPeriodType": "tstzrange"
	"DateTimeOpenEndPeriodType": "tstzrange"
	"DurationType": "interval"
	"EffectiveTimePeriodType": "tsrange"
	"FormattedDateTimeType": "timestamp"
	"OpenEndPeriodType": "tstzrange"
	"OrdinalType": "int4"
	"PeriodType": "tsrange"
	"Numbertype": "int4"
	"DateTimeType": "timestamp"
	"datetime": "timestamp"
	"TextTypeArray": "text[]"
	"StringTypeArray": "text[]"
}

[magick93]

Actually... ... I think I have it working now!

[verdverm]

Nice, I would just add that implementing unbounded (imprecise) recursion in CUE can very easily lead to performance issues

[magick93]

Can confirm

[verdverm]

I would recommend doing recursive things in Go if possible. Maybe I can expose something from structural to help here and avoid you needing to write Go in many of these cases

[magick93]

Its mostly working.

When I add if T.name == _|_ { T.newName: _ } to the below I get this error - missing ',' in struct literal:

I'm trying to add a newName key to structs that do not have a name.

missing ',' in struct literal:

properties: [string]: #TypeEnricher
#TypeEnricher: T={
	// required?: [string]
	#Property// embed proprty def
	if T.type != _|_ {
		psqlType: json2psql[T.type]
	}


	
	// #Property
	if T.title != _|_ {
		for k, v in hrxmlDateTypes {
			if T.title == k{
				postgresDateType: hrxmlDateTypes[T.title]
			}
		}
	}


// if T.name == _|_ { T.newName: _ } //--causes error

	if 	required != _|_ {
		for _, v in required {
			if T.name != _|_ {
				if T.name == v {
					notnull: true
				}
			}
		}
	}
	
	
}

[verdverm]

T.newName: _ should be T: newName: _

dotpaths are only possible for LHS expressions

[magick93]

Thanks, I tried that too.

if T.name == _|_ {
		T: newName: _
	}

This results in cannot have both alias and field with name "T" in same scope:

[magick93]

Got it!

properties?: #properties & {
			[pName=string]: #TypeEnricher
		}