How do we output fields with leading underscores?

[cakemanny]

Hi, how is it possible to produce a config with a leading underscore?

We want to use KCL to generate out declarative kong configuration. It fields _format_version and _transform. The _format_version is required.

Part of their example:

_format_version: "3.0"
_transform: true

services:
- name: my-service
 url: https://example.com
 plugins:
 - name: key-auth
 routes:
 - name: my-route
   paths:
   - /

We weren't able to find anything in the docs, e.g. in https://www.kcl-lang.io/docs/user_docs/support/faq-kcl

We also tried a few ideas but none were working

schema XYZ:
    [str]: str

xyz = {
    "_foo": "bar"
    "foo": "bar"
    xyz: XYZ {
        _bla: "bla"
    }
}

-->

xyz:
  foo: bar
  xyz: {}

[Peefy]

You can use the -H flag to show this fields. e.g., kcl main.k -H

[diefans]

So basically, if I need leading underscores, I need to sacrifice the "hiding feature"?

[cakemanny]

So, it would mean it that it's not possible to use variables with _ in that file in order to factor out common code anymore? And we would have to run kcl separately on those files.
This doesn't feel like a good solution....
Are there plans for a syntactical solution?
For reserved words we have the $ ... seems like there should be something for this case.

[cakemanny]

I guess combining the -H flag with path selection, -S, is starting to head in the right direction, as long as I keep the underscores out of the result type schemas:

schema Route:
    name: str
    paths: [str]

schema Plugin:
    name: str

schema Service:
    name: str
    url: str
    plugins: [Plugin]
    routes: [Route]

schema KongConfig:
    _format_version: str
    _transform: bool
    services: [Service]

_domain = "example"

out: KongConfig = {
    _format_version = "3.0"
    _transform = True

    services = [
        {
            name = "{}-service".format(_domain)
            url = "https://{}.com".format(_domain)
            plugins = [
                {
                    name = "key-auth"
                }
            ]
            routes = [
                {
                    name = "{}-route".format(_domain)
                    paths = ["/"]
                }
            ]
        }
    ]
}

% kcl kong.k -H -S out
_format_version: '3.0'
_transform: true
services:
- name: example-service
  url: https://example.com
  plugins:
  - name: key-auth
  routes:
  - name: example-route
    paths:
    - /

[nkabir]

Can you clarify what you meant by "as long as I keep the underscores out of the result type schemas"?

[cakemanny]

I just mean that in any of the schemas used to type the result expression -out in the example above - it's not possible to use leading underscore variables for intermediate results.

To give an example, based on the above, if I wanted to have a default service name I might normally write

schema Service:
    _default_name = url.removeprefix("https://").split(".")[-2] + "-service"
    name: str = name or _default_name
    url: str
    plugins: [Plugin]
    routes: [Route]

I use the intermediate _default_name to make it more readable what the code is doing.

However, since I am using -H and Service is used in the type of the services field in KongConfig, it will appear in the output, which I don't want in this case.

So, I have to find other ways to write such code.

[He1pa]

Using mixin to "assemble" an output dict, and in conjunction with "-H", does this approach meet your needs?

schema OriginConfig:
    _a?: str
    
    
schema ConfigProtocol:
    config: OriginConfig
    output: {str:}



mixin ConfigMixin for ConfigProtocol:
    if config._a:
        output = output | {"_a": config._a}


schema Config:
    mixin [
        ConfigMixin
    ]
    config: OriginConfig
    output: {str:}


Config{
    config: {
        _a = "aaa"
    }
}.output