Alias not kept after importing schema from sub-package?

[deepbrook]

Am I correct that declared aliases are resolved when importing a schema from another (sub)package ? Or am I missing something here?

Directory Structure

test/
  - cue.mod  # named "test.this"
  - schemas/
      - schema.cue
  - data.cue 

test/schemas/schema.cue

package schemas

#AppSetBase: {
    INPUTS=_inputs: {
        domain: string
        app: string
        ...
    }
    metadata: {
        name: "\(INPUTS.domain)-\(INPUTS.app)-app-set"
        namespace: "argocd"
    }
    spec: {
        goTemplate: true
        goTemplateOptions: ["missingkey=error"]
        template: {
            metadata: {
                namespace: "argocd"
            }
            spec: {
                destination: {
                    name: string
                    namespace: "argocd"
                }
                syncPolicy: {
                    automated: {
                        enabled: true
                        prune: true
                        selfHeal: true
                    }
                }
            }
        }
    }
}

test/data.cue

package validation
import "test.this/schemas"

appSet: schemas.#AppSetBase & {
  _inputs: {
	domain: "this"
	app: "that"
  }
}

Expected Result

> cue eval
❯ cue eval -H
appSet: {
    _inputs: {
        domain: "this"
        app:    "that"
    }
    metadata: {
        name:      "this-that-app-set"  // <---- Alias of schema.cue was honored and the string value interpolated
        namespace: "argocd"
    }
    spec: {
        goTemplate: true
        goTemplateOptions: ["missingkey=error"]
        template: {
            metadata: {
                namespace: "argocd"
            }
            spec: {
                destination: {
                    name:      string
                    namespace: "argocd"
                }
                syncPolicy: {
                    automated: {
                        enabled:  true
                        prune:    true
                        selfHeal: true
                    }
                }
            }
        }
    }
}

Actual Result

❯ cue eval -H
appSet: {
    _inputs: {
        domain: "this"
        app:    "that"
    }
    metadata: {
        name:      "\(_inputs.domain)-\(_inputs.app)-app-set"  // Appears to have resolved Alias during import?
        namespace: "argocd"
    }
    spec: {
        goTemplate: true
        goTemplateOptions: ["missingkey=error"]
        template: {
            metadata: {
                namespace: "argocd"
            }
            spec: {
                destination: {
                    name:      string
                    namespace: "argocd"
                }
                syncPolicy: {
                    automated: {
                        enabled:  true
                        prune:    true
                        selfHeal: true
                    }
                }
            }
        }
    }
}

Verification

As I stated above, it looks like aliases are resolved (and thus the respective values no longer dynamic) when imported. If I keep the cue files in the same package, it works as expected:

merged.cue

package merged


#AppSetBase: {
    INPUTS=_inputs: {
        domain: string
        app: string
        ...
    }
    metadata: {
        name: "\(INPUTS.domain)-\(INPUTS.app)-app-set"
        namespace: "argocd"
    }
    spec: {
        goTemplate: true
        goTemplateOptions: ["missingkey=error"]
        template: {
            metadata: {
                namespace: "argocd"
            }
            spec: {
                destination: {
                    name: string
                    namespace: "argocd"
                }
                syncPolicy: {
                    automated: {
                        enabled: true
                        prune: true
                        selfHeal: true
                    }
                }
            }
        }
    }
}

appSet: schemas.#AppSetBase & {
  _inputs: {
	domain: "this"
	app: "that"
  }
}

Result

❯ cue eval -H
#AppSetBase: {
    _inputs: {
        domain: string
        app:    string
    }
    metadata: {
        name:      "\(INPUTS.domain)-\(INPUTS.app)-app-set"
        namespace: "argocd"
    }
    spec: {
        goTemplate: true
        goTemplateOptions: ["missingkey=error"]
        template: {
            metadata: {
                namespace: "argocd"
            }
            spec: {
                destination: {
                    name:      string
                    namespace: "argocd"
                }
                syncPolicy: {
                    automated: {
                        enabled:  true
                        prune:    true
                        selfHeal: true
                    }
                }
            }
        }
    }
}
appSet: {
    _inputs: {
        domain: "this"
        app:    "that"
    }
    metadata: {
        name:      "this-that-app-set"
        namespace: "argocd"
    }
    spec: {
        goTemplate: true
        goTemplateOptions: ["missingkey=error"]
        template: {
            metadata: {
                namespace: "argocd"
            }
            spec: {
                destination: {
                    name:      string
                    namespace: "argocd"
                }
                syncPolicy: {
                    automated: {
                        enabled:  true
                        prune:    true
                        selfHeal: true
                    }
                }
            }
        }
    }
}

Is this the correct behaviour? Or is this a bug?

If it's expected, is the solution to this to keep these on the root?

I guess they're technically no longer a pure schema, but a function - but would that mean that functions would always have to live in the same package as they are used? Wouldn't that mean I'd have to duplicate function structs (what's the correct term for these?) alot?

Thanks for your help :)

Cheers