Cross-Package References & Implicit Dependencies

Cross-package references connect assets across packages using the {packageKey}#{assetKey} syntax. Some references carry implicit requirements that must be fulfilled for the referenced feature to work.

Reference Syntax

The qualified reference format is {packageKey}#{assetKey}. It applies to attribute types, components, relation types, icon keys, and any other asset that can be referenced across package boundaries.

{
  "attributeTypes": [
    { "key": "core#description" },
    { "key": "core#name" },
    { "key": "my_custom_attribute" }
  ]
}

Within the same package, use the key directly: description. From another package, use the full notation: core#description. The package key prefix tells the loader which package’s key registry to search.

Implicit Dependency Chains

A reference to an external asset may require additional declarations in your package for the feature to function. These implicit dependencies are not validated at installation time. The referenced component installs and renders, but shows no data or behaves incorrectly when dependencies are missing.

1. Ownership Panel

Adding core#ownership_generic to a template displays the ownership panel. This panel reads user relation data from the object instance.

Implicit requirement: The objectType must declare core_business_owner and core_steward in its userRelationTypes[] array.

{
  "key": "my_object_type",
  "userRelationTypes": [
    { "key": "core_business_owner" },
    { "key": "core_steward" }
  ],
  "templates": {
    "main": {
      "rightArea": [
        {
          "componentId": "core#ownership_generic",
          "type": "component"
        }
      ]
    }
  }
}

2. Search Forms

A working search form requires three connected assets, each with its own configuration:

1. searchIndex — defines which object types and attributes are indexed
2. searchQuery — defines how queries execute against the index
3. is_search_type_* features — on each indexed attribute type

Without all three, search either returns no results or omits expected attributes from results.

Missing piece	Symptom
No searchIndex	Search page loads but returns zero results for all queries
No searchQuery	Search form does not appear in the UI
No is_search_type_* features	Attribute values exist but are excluded from search results

3. Data Integration

Connecting to an external data source requires three entities:

1. dataSourceDefinition — schema describing the source structure
2. externalDataSource — connection configuration (endpoint, credentials reference)
3. provider — the integration provider type (e.g., JDBC, REST, file-based)

Missing any one of these causes the integration to fail at scan time, not at installation time. The package installs without error.

4. Hierarchy Display

Displaying objects in a tree structure requires:

1. hierarchyDefinition — defines the parent-child relationship logic
2. hierarchyDefinitionApplication — maps the hierarchy to specific object types

Without the application mapping, the hierarchy definition exists in the database but no object type uses it. The tree view does not appear in the UI.

5. Codetable Dropdown

A codetable-backed dropdown requires:

1. A codetable objectType with entries (each having label and value)
2. The acceptableCodetableValues feature on the attribute type, referencing the codetable objectType key

If the codetable objectType does not exist or has no entries, the dropdown renders but shows an empty list.

6. Hierarchy navigation: An application’s hierarchyDefinitions[] array references a hierarchyDefinition asset by key. The hierarchy levels reference objectType keys. The objectTypeRelations must define core#isParentOf relationships matching the hierarchy level order. Missing any piece = objects appear in flat lists only.

7. Data integration wiring: A connector application’s dataIntegrations[] array references dataSourceDefinition assets. The data source definition references a provider asset. Without the complete chain (application → dataIntegration → dataSourceDefinition → provider), the connector’s scan button does not appear.

What the Core Package Provides

The core package is the foundation that most packages reference. Understanding its available assets prevents unnecessary custom definitions.

Attribute Types (50+)

General-purpose attributes covering:

• Text: core#name, core#description, core#abbreviation, core#note
• URLs: core#url, core#source_url
• Dates: core#date_created, core#date_modified, core#date_valid_from, core#date_valid_to
• Identifiers: core#external_id, core#code
• Counts and metrics: core#count, core#row_count
• Classifications: core#classification, core#tag

Icon Keys (30+)

Icon keys follow the pattern core_{descriptive_name}:

• core_folder, core_file, core_database, core_table
• core_chart, core_dashboard, core_report
• core_user, core_group, core_organization
• core_link, core_tag, core_lock, core_settings

Shared Components

• core#ownership_generic — ownership panel (requires userRelationTypes)
• core#classification_generic — classification tag display
• core#data_quality_generic — data quality score panel
• core#lineage_generic — lineage visualization component

User Relation Types

• core_business_owner — primary business responsibility
• core_steward — data governance steward
• core_data_owner — technical data ownership
• core_technical_contact — technical point of contact

Discovering Available Core Assets

Two approaches for exploring what the core package offers:

1. Inspect the core package JSON. Open the package export and search for the asset type you need. Keys are consistent and descriptive.
2. Use the split-merge tool. The split tool breaks a package into individual part files. Browse the parts directory to see each asset type, attribute type, and component as a separate file.

The split-merge tool is documented in the Package Installation Pipeline article.

Complete Example: ObjectType with All Dependencies

An objectType that uses ownership, search, hierarchy, and classification — with all implicit dependencies declared:

{
  "key": "data_product",
  "name": "Data Product",
  "iconKey": "core_database",
  "colorKey": "core_blue",
  "attributeTypes": [
    { "key": "core#name" },
    {
      "key": "core#description",
      "features": [
        { "key": "is_search_type_text", "value": true },
        { "key": "is_search_default_result_text", "value": true }
      ]
    },
    {
      "key": "core#classification",
      "features": [
        { "key": "is_search_type_term", "value": true }
      ]
    }
  ],
  "userRelationTypes": [
    { "key": "core_business_owner" },
    { "key": "core_steward" }
  ],
  "hierarchyDefinitionApplications": [
    { "hierarchyDefinitionKey": "my_package#product_hierarchy" }
  ],
  "searchIndex": {
    "key": "data_product_index",
    "objectTypeKeys": ["data_product"]
  },
  "searchQuery": {
    "key": "data_product_search",
    "searchIndexKey": "data_product_index"
  },
  "templates": {
    "main": {
      "centerArea": [
        {
          "componentId": "data_product#attr#description",
          "type": "attributes",
          "values": ["core#description"]
        }
      ],
      "rightArea": [
        {
          "componentId": "core#ownership_generic",
          "type": "component"
        },
        {
          "componentId": "core#classification_generic",
          "type": "component"
        }
      ]
    }
  }
}

Every implicit dependency is satisfied:

• Ownership panel: userRelationTypes includes core_business_owner and core_steward
• Search: searchIndex + searchQuery + is_search_type_* features on attributes
• Hierarchy: hierarchyDefinitionApplications references a declared hierarchy
• Classification: core#classification_generic component + classification attribute type
• Icons and colors: core_database and core_blue are valid core keys

Dependency Resolution Order

During installation, the loader resolves cross-package references in two steps:

1. Package lookup. The system verifies the referenced package is installed. If the package is not found, validation fails with an explicit error.
2. Asset lookup. The system searches the referenced package’s key registry for the asset key. If the key is not found, the behavior depends on the asset type — some raise errors, others fail silently.

Asset type	Missing reference behavior
Attribute type	Validation error — blocks installation
Icon key	Silent — renders blank space
Color key	Silent — renders default color
Component	Silent — panel renders empty
User relation type	Silent — feature renders without data

Gotchas