diff --git a/openmetadata-docs/content/v1.8.x/how-to-guides/data-governance/automation/index.md b/openmetadata-docs/content/v1.8.x/how-to-guides/data-governance/automation/index.md index bf7f5cbb664..4ead15f6d55 100644 --- a/openmetadata-docs/content/v1.8.x/how-to-guides/data-governance/automation/index.md +++ b/openmetadata-docs/content/v1.8.x/how-to-guides/data-governance/automation/index.md @@ -95,6 +95,80 @@ For the Action Configuration: As with other actions, you can choose to **Overwrite Metadata** or keep the existing metadata and only apply the new metadata to assets that do not have the metadata already. +#### Advanced Propagation Controls + +{% image +src="images/v1.8/how-to-guides/governance/automator-propagation-advance-config.png" +alt="Automation advanced propagation controls" +caption="Automation advanced propagation controls" +/%} + +##### Propagation Depth + +The **Propagation Depth** feature allows you to limit how far metadata propagates through your lineage tree: + +- **Use Case**: In complex lineage with many edges, you might want to limit how far metadata flows to maintain control and relevance. +- **Configuration**: + - Leave it blank to allow complete propagation + - Set a positive integer (e.g., 1, 2, 3) to limit propagation to specific levels from the root +- **How it works**: + - Root entities (those with no upstream lineage) start at depth 0 + - Each downstream neighbor increases the depth by 1 + - Depth is calculated separately for each path from each root entity + - Example: In lineage A → B → C → D + - A is at depth 0 (root) + - B is at depth 1 + - C is at depth 2 + - D is at depth 3 + - Setting depth to 2 means metadata flows only to assets at depth 2 or less (B and C in above example) + +- **Advanced Scenario - Complex Lineage**: + - In scenarios with multiple parent paths (e.g., A → B → C and D → C), depth is calculated for each path independently + - With propagation depth = 1: C would receive metadata from D (depth 1 from D) but not from A via B (depth 2 from A) + - This path-aware approach provides precise control over which upstream sources contribute to each downstream asset + +**When to use**: +- When you have deep lineage chains and want to prevent metadata from propagating too far downstream +- When you want to maintain control over which downstream assets receive propagated metadata +- For performance optimization in very large lineage graphs + +##### Stop Propagation Conditions + +The **Stop Propagation** feature lets you halt metadata flow when certain conditions are matched (e.g., sensitive data markers are encountered): + +- **Use Case**: Prevent metadata propagation at specific condition. +- **Supported Attributes**: + - `description`: Stop when specific description text is found + - `tags`: Stop when specific tags are present + - `glossaryTerms`: Stop when specific glossary terms are found + - `owner`: Stop when specific owners are assigned + - `tier`: Stop when specific tier levels are encountered + - `domain`: Stop when specific domains are assigned + +**Important Note**: When a stop condition is matched at a node, the propagation stops AT that node. The node retains its original metadata, and propagation does not continue to its downstream assets. + +**Examples**: +1. **Sensitive Data Boundaries**: Stop at nodes tagged as "Confidential" or "PII-Sensitive" +2. **Organizational Boundaries**: Halt at assets owned by specific teams +3. **Domain Transitions**: Stop when crossing into different business domains +4. **Quality Thresholds**: Pause at specific tier levels + +**How it works**: +- The system evaluates metadata at each node during propagation +- When matching any specified condition, propagation stops at that node +- Intelligent matching handles various formats (HTML in descriptions, object types) +- Existing metadata at the stop point remains unchanged + +**Configuration Example**: +```yaml +Stop Conditions Examples: + - Metadata: Tags + Values: ["PII.Sensitive", "Confidential"] + - Metadata: Domain + Values: ["Finance", "Legal"] + - Metadata: Description + Values: ["DO NOT PROPAGATE"] +``` ### 5. Automatic PII Detection and Tagging @@ -122,3 +196,6 @@ Note that this automation, the ML Tagging, will be deprecated in future releases - **Validate Assets Before Applying Actions**: Always use the **Explore** page to verify the assets that will be affected by the automation. This ensures that only the intended datasets are updated. - **Use Automation Logs**: Regularly check the **Recent Runs** logs to monitor automation activity and ensure that they are running as expected. - **Propagate Metadata Thoughtfully**: When propagating metadata via lineage, make sure that the source metadata is correct before applying it across multiple datasets. +- **Start with Controlled Propagation**: For complex and large lineage trees, begin the propagation with a limited propagation depth (e.g., 2-3 levels/depth) and gradually increase as needed to avoid unintended widespread changes. +- **Understand Path-Aware Depth Behavior**: In complex lineage with multiple parent paths, remember that propagation depth is calculated separately for each path from each root entity. This ensures precise control over which upstream sources contribute metadata to downstream assets. +- **Set Up Stop Conditions for Critical Data**: Cofigure strategic stop conditions around critical ownership boundaries or sensitive data boundaries (Tags- PII, Confidential) to prevent accidental metadata overwrites. diff --git a/openmetadata-docs/content/v1.9.x-SNAPSHOT/how-to-guides/data-governance/automation/index.md b/openmetadata-docs/content/v1.9.x-SNAPSHOT/how-to-guides/data-governance/automation/index.md index 90bc3e53d47..dc9d6844d05 100644 --- a/openmetadata-docs/content/v1.9.x-SNAPSHOT/how-to-guides/data-governance/automation/index.md +++ b/openmetadata-docs/content/v1.9.x-SNAPSHOT/how-to-guides/data-governance/automation/index.md @@ -95,6 +95,80 @@ For the Action Configuration: As with other actions, you can choose to **Overwrite Metadata** or keep the existing metadata and only apply the new metadata to assets that do not have the metadata already. +#### Advanced Propagation Controls + +{% image +src="/images/v1.9/how-to-guides/governance/automator-propagation-advance-config.png" +alt="Automation advanced propagation controls" +caption="Automation advanced propagation controls" +/%} + +##### Propagation Depth + +The **Propagation Depth** feature allows you to limit how far metadata propagates through your lineage tree: + +- **Use Case**: In complex lineage with many edges, you might want to limit how far metadata flows to maintain control and relevance. +- **Configuration**: + - Leave it blank to allow complete propagation + - Set a positive integer (e.g., 1, 2, 3) to limit propagation to specific levels from the root +- **How it works**: + - Root entities (those with no upstream lineage) start at depth 0 + - Each downstream neighbor increases the depth by 1 + - Depth is calculated separately for each path from each root entity + - Example: In lineage A → B → C → D + - A is at depth 0 (root) + - B is at depth 1 + - C is at depth 2 + - D is at depth 3 + - Setting depth to 2 means metadata flows only to assets at depth 2 or less (B and C in above example) + +- **Advanced Scenario - Complex Lineage**: + - In scenarios with multiple parent paths (e.g., A → B → C and D → C), depth is calculated for each path independently + - With propagation depth = 1: C would receive metadata from D (depth 1 from D) but not from A via B (depth 2 from A) + - This path-aware approach provides precise control over which upstream sources contribute to each downstream asset + +**When to use**: +- When you have deep lineage chains and want to prevent metadata from propagating too far downstream +- When you want to maintain control over which downstream assets receive propagated metadata +- For performance optimization in very large lineage graphs + +##### Stop Propagation Conditions + +The **Stop Propagation** feature lets you halt metadata flow when certain conditions are matched (e.g., sensitive data markers are encountered): + +- **Use Case**: Prevent metadata propagation at specific condition. +- **Supported Attributes**: + - `description`: Stop when specific description text is found + - `tags`: Stop when specific tags are present + - `glossaryTerms`: Stop when specific glossary terms are found + - `owner`: Stop when specific owners are assigned + - `tier`: Stop when specific tier levels are encountered + - `domain`: Stop when specific domains are assigned + +**Important Note**: When a stop condition is matched at a node, the propagation stops AT that node. The node retains its original metadata, and propagation does not continue to its downstream assets. + +**Examples**: +1. **Sensitive Data Boundaries**: Stop at nodes tagged as "Confidential" or "PII-Sensitive" +2. **Organizational Boundaries**: Halt at assets owned by specific teams +3. **Domain Transitions**: Stop when crossing into different business domains +4. **Quality Thresholds**: Pause at specific tier levels + +**How it works**: +- The system evaluates metadata at each node during propagation +- When matching any specified condition, propagation stops at that node +- Intelligent matching handles various formats (HTML in descriptions, object types) +- Existing metadata at the stop point remains unchanged + +**Configuration Example**: +```yaml +Stop Conditions Examples: + - Metadata: Tags + Values: ["PII.Sensitive", "Confidential"] + - Metadata: Domain + Values: ["Finance", "Legal"] + - Metadata: Description + Values: ["DO NOT PROPAGATE"] +``` ### 5. Automatic PII Detection and Tagging @@ -122,3 +196,6 @@ Note that this automation, the ML Tagging, will be deprecated in future releases - **Validate Assets Before Applying Actions**: Always use the **Explore** page to verify the assets that will be affected by the automation. This ensures that only the intended datasets are updated. - **Use Automation Logs**: Regularly check the **Recent Runs** logs to monitor automation activity and ensure that they are running as expected. - **Propagate Metadata Thoughtfully**: When propagating metadata via lineage, make sure that the source metadata is correct before applying it across multiple datasets. +- **Start with Controlled Propagation**: For complex and large lineage trees, begin the propagation with a limited propagation depth (e.g., 2-3 levels/depth) and gradually increase as needed to avoid unintended widespread changes. +- **Understand Path-Aware Depth Behavior**: In complex lineage with multiple parent paths, remember that propagation depth is calculated separately for each path from each root entity. This ensures precise control over which upstream sources contribute metadata to downstream assets. +- **Set Up Stop Conditions for Critical Data**: Cofigure strategic stop conditions around critical ownership boundaries or sensitive data boundaries (Tags- PII, Confidential) to prevent accidental metadata overwrites. diff --git a/openmetadata-docs/images/v1.8/how-to-guides/governance/automator-propagation-advance-config.png b/openmetadata-docs/images/v1.8/how-to-guides/governance/automator-propagation-advance-config.png new file mode 100644 index 00000000000..1f4adbb6b74 Binary files /dev/null and b/openmetadata-docs/images/v1.8/how-to-guides/governance/automator-propagation-advance-config.png differ diff --git a/openmetadata-docs/images/v1.9/how-to-guides/governance/automator-propagation-advance-config.png b/openmetadata-docs/images/v1.9/how-to-guides/governance/automator-propagation-advance-config.png new file mode 100644 index 00000000000..1f4adbb6b74 Binary files /dev/null and b/openmetadata-docs/images/v1.9/how-to-guides/governance/automator-propagation-advance-config.png differ diff --git a/openmetadata-spec/src/main/resources/json/schema/entity/applications/configuration/external/automator/lineagePropagationAction.json b/openmetadata-spec/src/main/resources/json/schema/entity/applications/configuration/external/automator/lineagePropagationAction.json index 9f34ae14656..231f729e3b9 100644 --- a/openmetadata-spec/src/main/resources/json/schema/entity/applications/configuration/external/automator/lineagePropagationAction.json +++ b/openmetadata-spec/src/main/resources/json/schema/entity/applications/configuration/external/automator/lineagePropagationAction.json @@ -72,6 +72,21 @@ "description": "Update descriptions, tags and Glossary Terms via lineage even if they are already defined in the asset. By default, descriptions are only updated if they are not already defined in the asset, and incoming tags are merged with the existing ones.", "type": "boolean", "default": false + }, + "propagationDepth": { + "title": "Propagation Depth", + "description": "Number of levels to propagate lineage. If not set, it will propagate to all levels.", + "type": "integer", + "default": null + }, + "propagationStopConfigs": { + "title": "Propagation Stop Configurations", + "description": "List of configurations to stop propagation based on conditions", + "type": "array", + "default": null, + "items": { + "$ref": "propagationStopConfig.json" + } } }, "required": ["type"], diff --git a/openmetadata-spec/src/main/resources/json/schema/entity/applications/configuration/external/automator/propagationStopConfig.json b/openmetadata-spec/src/main/resources/json/schema/entity/applications/configuration/external/automator/propagationStopConfig.json new file mode 100644 index 00000000000..d81635001f6 --- /dev/null +++ b/openmetadata-spec/src/main/resources/json/schema/entity/applications/configuration/external/automator/propagationStopConfig.json @@ -0,0 +1,45 @@ +{ + "$id": "https://open-metadata.org/schema/entity/applications/configuration/external/automator/propagationStopConfig.json", + "$schema": "http://json-schema.org/draft-07/schema#", + "title": "PropagationStopConfig", + "description": "Configuration to stop lineage propagation based on conditions", + "type": "object", + "properties": { + "metadataAttribute": { + "title": "Metadata Attribute", + "description": "The metadata attribute to check for stopping propagation", + "type": "string", + "enum": [ + "description", + "tags", + "glossaryTerms", + "owner", + "tier", + "domain" + ] + }, + "value": { + "title": "Stop Values", + "description": "List of attribute values that will stop propagation when any of them is matched", + "type": "array", + "items": { + "oneOf": [ + { + "type": "string" + }, + { + "$ref": "../../../../../type/tagLabel.json" + }, + { + "$ref": "../../../../../type/entityReference.json" + } + ] + } + } + }, + "required": [ + "metadataAttribute", + "value" + ], + "additionalProperties": false +} \ No newline at end of file diff --git a/openmetadata-ui/src/main/resources/ui/src/generated/api/services/ingestionPipelines/createIngestionPipeline.ts b/openmetadata-ui/src/main/resources/ui/src/generated/api/services/ingestionPipelines/createIngestionPipeline.ts index ada1db29006..960b98c79fd 100644 --- a/openmetadata-ui/src/main/resources/ui/src/generated/api/services/ingestionPipelines/createIngestionPipeline.ts +++ b/openmetadata-ui/src/main/resources/ui/src/generated/api/services/ingestionPipelines/createIngestionPipeline.ts @@ -1019,7 +1019,7 @@ export interface Action { * * Tags to remove */ - tags?: TagLabel[]; + tags?: TierElement[]; /** * Application Type */ @@ -1051,7 +1051,7 @@ export interface Action { /** * tier to apply */ - tier?: TagLabel; + tier?: TierElement; /** * Test Cases to apply */ @@ -1106,6 +1106,14 @@ export interface Action { * Propagate tier from the parent */ propagateTier?: boolean; + /** + * Number of levels to propagate lineage. If not set, it will propagate to all levels. + */ + propagationDepth?: number; + /** + * List of configurations to stop propagation based on conditions + */ + propagationStopConfigs?: PropagationStopConfig[]; } /** @@ -1117,22 +1125,74 @@ export enum LabelElement { Propagated = "Propagated", } +/** + * Configuration to stop lineage propagation based on conditions + */ +export interface PropagationStopConfig { + /** + * The metadata attribute to check for stopping propagation + */ + metadataAttribute: MetadataAttribute; + /** + * List of attribute values that will stop propagation when any of them is matched + */ + value: Array; +} + +/** + * The metadata attribute to check for stopping propagation + */ +export enum MetadataAttribute { + Description = "description", + Domain = "domain", + GlossaryTerms = "glossaryTerms", + Owner = "owner", + Tags = "tags", + Tier = "tier", +} + /** * This schema defines the type for labeling an entity with a Tag. * * tier to apply + * + * Owner of this Ingestion Pipeline. + * + * This schema defines the EntityReferenceList type used for referencing an entity. + * EntityReference is used for capturing relationships from one entity to another. For + * example, a table has an attribute called database of type EntityReference that captures + * the relationship of a table `belongs to a` database. + * + * This schema defines the EntityReference type used for referencing an entity. + * EntityReference is used for capturing relationships from one entity to another. For + * example, a table has an attribute called database of type EntityReference that captures + * the relationship of a table `belongs to a` database. + * + * The processing engine responsible for executing the ingestion pipeline logic. + * + * Link to the service for which ingestion pipeline is ingesting the metadata. + * + * Domain to apply + * + * Service to be modified */ export interface TagLabel { /** * Description for the tag label. + * + * Optional description of entity. */ description?: string; /** * Display Name that identifies this tag. + * + * Display Name that identifies this entity. */ displayName?: string; /** * Link to the tag resource. + * + * Link to the entity resource. */ href?: string; /** @@ -1142,22 +1202,48 @@ export interface TagLabel { * label was propagated from upstream based on lineage. 'Automated' is used when a tool was * used to determine the tag label. */ - labelType: LabelTypeEnum; + labelType?: LabelTypeEnum; /** * Name of the tag or glossary term. + * + * Name of the entity instance. */ name?: string; /** * Label is from Tags or Glossary. */ - source: TagSource; + source?: TagSource; /** * 'Suggested' state is used when a tag label is suggested by users or tools. Owner of the * entity must confirm the suggested labels before it is marked as 'Confirmed'. */ - state: State; - style?: Style; - tagFQN: string; + state?: State; + style?: Style; + tagFQN?: string; + /** + * If true the entity referred to has been soft-deleted. + */ + deleted?: boolean; + /** + * Fully qualified name of the entity instance. For entities such as tables, databases + * fullyQualifiedName is returned in this field. For entities that don't have name hierarchy + * such as `user` and `team` this will be same as the `name` field. + */ + fullyQualifiedName?: string; + /** + * Unique identifier that identifies an entity instance. + */ + id?: string; + /** + * If true the relationship indicated by this entity reference is inherited from the parent + * entity. + */ + inherited?: boolean; + /** + * Entity type/class name - Examples: `database`, `table`, `metrics`, `databaseService`, + * `dashboardService`... + */ + type?: string; } /** @@ -1207,6 +1293,49 @@ export interface Style { iconURL?: string; } +/** + * This schema defines the type for labeling an entity with a Tag. + * + * tier to apply + */ +export interface TierElement { + /** + * Description for the tag label. + */ + description?: string; + /** + * Display Name that identifies this tag. + */ + displayName?: string; + /** + * Link to the tag resource. + */ + href?: string; + /** + * Label type describes how a tag label was applied. 'Manual' indicates the tag label was + * applied by a person. 'Derived' indicates a tag label was derived using the associated tag + * relationship (see Classification.json for more details). 'Propagated` indicates a tag + * label was propagated from upstream based on lineage. 'Automated' is used when a tool was + * used to determine the tag label. + */ + labelType: LabelTypeEnum; + /** + * Name of the tag or glossary term. + */ + name?: string; + /** + * Label is from Tags or Glossary. + */ + source: TagSource; + /** + * 'Suggested' state is used when a tag label is suggested by users or tools. Owner of the + * entity must confirm the suggested labels before it is marked as 'Confirmed'. + */ + state: State; + style?: Style; + tagFQN: string; +} + /** * Minimum set of requirements to get a Test Case request ready */ @@ -1219,7 +1348,7 @@ export interface TestCaseDefinitions { /** * Tags to apply */ - tags?: TagLabel[]; + tags?: TierElement[]; /** * Fully qualified name of the test definition. */ @@ -1890,11 +2019,11 @@ export interface ReverseIngestionConfig { /** * Added tags to be applied */ - addedTags?: TagLabel[]; + addedTags?: TierElement[]; /** * Removed tags of the entity */ - removedTags?: TagLabel[]; + removedTags?: TierElement[]; } /** diff --git a/openmetadata-ui/src/main/resources/ui/src/generated/entity/applications/app.ts b/openmetadata-ui/src/main/resources/ui/src/generated/entity/applications/app.ts index c67ba8d3ffb..1d78d9f6ea2 100644 --- a/openmetadata-ui/src/main/resources/ui/src/generated/entity/applications/app.ts +++ b/openmetadata-ui/src/main/resources/ui/src/generated/entity/applications/app.ts @@ -407,7 +407,7 @@ export interface Action { * * Tags to remove */ - tags?: TagLabel[]; + tags?: TierElement[]; /** * Application Type */ @@ -439,7 +439,7 @@ export interface Action { /** * tier to apply */ - tier?: TagLabel; + tier?: TierElement; /** * Test Cases to apply */ @@ -494,6 +494,14 @@ export interface Action { * Propagate tier from the parent */ propagateTier?: boolean; + /** + * Number of levels to propagate lineage. If not set, it will propagate to all levels. + */ + propagationDepth?: number; + /** + * List of configurations to stop propagation based on conditions + */ + propagationStopConfigs?: PropagationStopConfig[]; } /** @@ -565,22 +573,73 @@ export enum LabelElement { Propagated = "Propagated", } +/** + * Configuration to stop lineage propagation based on conditions + */ +export interface PropagationStopConfig { + /** + * The metadata attribute to check for stopping propagation + */ + metadataAttribute: MetadataAttribute; + /** + * List of attribute values that will stop propagation when any of them is matched + */ + value: Array; +} + +/** + * The metadata attribute to check for stopping propagation + */ +export enum MetadataAttribute { + Description = "description", + Domain = "domain", + GlossaryTerms = "glossaryTerms", + Owner = "owner", + Tags = "tags", + Tier = "tier", +} + /** * This schema defines the type for labeling an entity with a Tag. * * tier to apply + * + * Domain to apply + * + * This schema defines the EntityReference type used for referencing an entity. + * EntityReference is used for capturing relationships from one entity to another. For + * example, a table has an attribute called database of type EntityReference that captures + * the relationship of a table `belongs to a` database. + * + * Owners to apply + * + * This schema defines the EntityReferenceList type used for referencing an entity. + * EntityReference is used for capturing relationships from one entity to another. For + * example, a table has an attribute called database of type EntityReference that captures + * the relationship of a table `belongs to a` database. + * + * Bot User Associated with this application. + * + * Domain the asset belongs to. When not set, the asset inherits the domain from the parent + * it belongs to. */ export interface TagLabel { /** * Description for the tag label. + * + * Optional description of entity. */ description?: string; /** * Display Name that identifies this tag. + * + * Display Name that identifies this entity. */ displayName?: string; /** * Link to the tag resource. + * + * Link to the entity resource. */ href?: string; /** @@ -590,22 +649,48 @@ export interface TagLabel { * label was propagated from upstream based on lineage. 'Automated' is used when a tool was * used to determine the tag label. */ - labelType: LabelTypeEnum; + labelType?: LabelTypeEnum; /** * Name of the tag or glossary term. + * + * Name of the entity instance. */ name?: string; /** * Label is from Tags or Glossary. */ - source: TagSource; + source?: TagSource; /** * 'Suggested' state is used when a tag label is suggested by users or tools. Owner of the * entity must confirm the suggested labels before it is marked as 'Confirmed'. */ - state: State; - style?: Style; - tagFQN: string; + state?: State; + style?: Style; + tagFQN?: string; + /** + * If true the entity referred to has been soft-deleted. + */ + deleted?: boolean; + /** + * Fully qualified name of the entity instance. For entities such as tables, databases + * fullyQualifiedName is returned in this field. For entities that don't have name hierarchy + * such as `user` and `team` this will be same as the `name` field. + */ + fullyQualifiedName?: string; + /** + * Unique identifier that identifies an entity instance. + */ + id?: string; + /** + * If true the relationship indicated by this entity reference is inherited from the parent + * entity. + */ + inherited?: boolean; + /** + * Entity type/class name - Examples: `database`, `table`, `metrics`, `databaseService`, + * `dashboardService`... + */ + type?: string; } /** @@ -655,6 +740,49 @@ export interface Style { iconURL?: string; } +/** + * This schema defines the type for labeling an entity with a Tag. + * + * tier to apply + */ +export interface TierElement { + /** + * Description for the tag label. + */ + description?: string; + /** + * Display Name that identifies this tag. + */ + displayName?: string; + /** + * Link to the tag resource. + */ + href?: string; + /** + * Label type describes how a tag label was applied. 'Manual' indicates the tag label was + * applied by a person. 'Derived' indicates a tag label was derived using the associated tag + * relationship (see Classification.json for more details). 'Propagated` indicates a tag + * label was propagated from upstream based on lineage. 'Automated' is used when a tool was + * used to determine the tag label. + */ + labelType: LabelTypeEnum; + /** + * Name of the tag or glossary term. + */ + name?: string; + /** + * Label is from Tags or Glossary. + */ + source: TagSource; + /** + * 'Suggested' state is used when a tag label is suggested by users or tools. Owner of the + * entity must confirm the suggested labels before it is marked as 'Confirmed'. + */ + state: State; + style?: Style; + tagFQN: string; +} + /** * Minimum set of requirements to get a Test Case request ready */ @@ -667,7 +795,7 @@ export interface TestCaseDefinitions { /** * Tags to apply */ - tags?: TagLabel[]; + tags?: TierElement[]; /** * Fully qualified name of the test definition. */ diff --git a/openmetadata-ui/src/main/resources/ui/src/generated/entity/applications/configuration/external/automator/lineagePropagationAction.ts b/openmetadata-ui/src/main/resources/ui/src/generated/entity/applications/configuration/external/automator/lineagePropagationAction.ts index f83d625636e..b0b2ce08eee 100644 --- a/openmetadata-ui/src/main/resources/ui/src/generated/entity/applications/configuration/external/automator/lineagePropagationAction.ts +++ b/openmetadata-ui/src/main/resources/ui/src/generated/entity/applications/configuration/external/automator/lineagePropagationAction.ts @@ -52,12 +52,171 @@ export interface LineagePropagationAction { * Propagate tier from the parent */ propagateTier?: boolean; + /** + * Number of levels to propagate lineage. If not set, it will propagate to all levels. + */ + propagationDepth?: number; + /** + * List of configurations to stop propagation based on conditions + */ + propagationStopConfigs?: PropagationStopConfig[]; /** * Application Type */ type: LineagePropagationActionType; } +/** + * Configuration to stop lineage propagation based on conditions + */ +export interface PropagationStopConfig { + /** + * The metadata attribute to check for stopping propagation + */ + metadataAttribute: MetadataAttribute; + /** + * List of attribute values that will stop propagation when any of them is matched + */ + value: Array; +} + +/** + * The metadata attribute to check for stopping propagation + */ +export enum MetadataAttribute { + Description = "description", + Domain = "domain", + GlossaryTerms = "glossaryTerms", + Owner = "owner", + Tags = "tags", + Tier = "tier", +} + +/** + * This schema defines the type for labeling an entity with a Tag. + * + * This schema defines the EntityReference type used for referencing an entity. + * EntityReference is used for capturing relationships from one entity to another. For + * example, a table has an attribute called database of type EntityReference that captures + * the relationship of a table `belongs to a` database. + */ +export interface TagLabel { + /** + * Description for the tag label. + * + * Optional description of entity. + */ + description?: string; + /** + * Display Name that identifies this tag. + * + * Display Name that identifies this entity. + */ + displayName?: string; + /** + * Link to the tag resource. + * + * Link to the entity resource. + */ + href?: string; + /** + * Label type describes how a tag label was applied. 'Manual' indicates the tag label was + * applied by a person. 'Derived' indicates a tag label was derived using the associated tag + * relationship (see Classification.json for more details). 'Propagated` indicates a tag + * label was propagated from upstream based on lineage. 'Automated' is used when a tool was + * used to determine the tag label. + */ + labelType?: LabelType; + /** + * Name of the tag or glossary term. + * + * Name of the entity instance. + */ + name?: string; + /** + * Label is from Tags or Glossary. + */ + source?: TagSource; + /** + * 'Suggested' state is used when a tag label is suggested by users or tools. Owner of the + * entity must confirm the suggested labels before it is marked as 'Confirmed'. + */ + state?: State; + style?: Style; + tagFQN?: string; + /** + * If true the entity referred to has been soft-deleted. + */ + deleted?: boolean; + /** + * Fully qualified name of the entity instance. For entities such as tables, databases + * fullyQualifiedName is returned in this field. For entities that don't have name hierarchy + * such as `user` and `team` this will be same as the `name` field. + */ + fullyQualifiedName?: string; + /** + * Unique identifier that identifies an entity instance. + */ + id?: string; + /** + * If true the relationship indicated by this entity reference is inherited from the parent + * entity. + */ + inherited?: boolean; + /** + * Entity type/class name - Examples: `database`, `table`, `metrics`, `databaseService`, + * `dashboardService`... + */ + type?: string; +} + +/** + * Label type describes how a tag label was applied. 'Manual' indicates the tag label was + * applied by a person. 'Derived' indicates a tag label was derived using the associated tag + * relationship (see Classification.json for more details). 'Propagated` indicates a tag + * label was propagated from upstream based on lineage. 'Automated' is used when a tool was + * used to determine the tag label. + */ +export enum LabelType { + Automated = "Automated", + Derived = "Derived", + Generated = "Generated", + Manual = "Manual", + Propagated = "Propagated", +} + +/** + * Label is from Tags or Glossary. + */ +export enum TagSource { + Classification = "Classification", + Glossary = "Glossary", +} + +/** + * 'Suggested' state is used when a tag label is suggested by users or tools. Owner of the + * entity must confirm the suggested labels before it is marked as 'Confirmed'. + */ +export enum State { + Confirmed = "Confirmed", + Suggested = "Suggested", +} + +/** + * UI Style is used to associate a color code and/or icon to entity to customize the look of + * that entity in UI. + */ +export interface Style { + /** + * Hex Color Code to mark an entity such as GlossaryTerm, Tag, Domain or Data Product. + */ + color?: string; + /** + * An icon to associate with GlossaryTerm, Tag, Domain or Data Product. + */ + iconURL?: string; +} + /** * Application Type * diff --git a/openmetadata-ui/src/main/resources/ui/src/generated/entity/applications/configuration/external/automator/propagationStopConfig.ts b/openmetadata-ui/src/main/resources/ui/src/generated/entity/applications/configuration/external/automator/propagationStopConfig.ts new file mode 100644 index 00000000000..908f7efa5c4 --- /dev/null +++ b/openmetadata-ui/src/main/resources/ui/src/generated/entity/applications/configuration/external/automator/propagationStopConfig.ts @@ -0,0 +1,162 @@ +/* + * Copyright 2025 Collate. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * http://www.apache.org/licenses/LICENSE-2.0 + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +/** + * Configuration to stop lineage propagation based on conditions + */ +export interface PropagationStopConfig { + /** + * The metadata attribute to check for stopping propagation + */ + metadataAttribute: MetadataAttribute; + /** + * List of attribute values that will stop propagation when any of them is matched + */ + value: Array; +} + +/** + * The metadata attribute to check for stopping propagation + */ +export enum MetadataAttribute { + Description = "description", + Domain = "domain", + GlossaryTerms = "glossaryTerms", + Owner = "owner", + Tags = "tags", + Tier = "tier", +} + +/** + * This schema defines the type for labeling an entity with a Tag. + * + * This schema defines the EntityReference type used for referencing an entity. + * EntityReference is used for capturing relationships from one entity to another. For + * example, a table has an attribute called database of type EntityReference that captures + * the relationship of a table `belongs to a` database. + */ +export interface TagLabel { + /** + * Description for the tag label. + * + * Optional description of entity. + */ + description?: string; + /** + * Display Name that identifies this tag. + * + * Display Name that identifies this entity. + */ + displayName?: string; + /** + * Link to the tag resource. + * + * Link to the entity resource. + */ + href?: string; + /** + * Label type describes how a tag label was applied. 'Manual' indicates the tag label was + * applied by a person. 'Derived' indicates a tag label was derived using the associated tag + * relationship (see Classification.json for more details). 'Propagated` indicates a tag + * label was propagated from upstream based on lineage. 'Automated' is used when a tool was + * used to determine the tag label. + */ + labelType?: LabelType; + /** + * Name of the tag or glossary term. + * + * Name of the entity instance. + */ + name?: string; + /** + * Label is from Tags or Glossary. + */ + source?: TagSource; + /** + * 'Suggested' state is used when a tag label is suggested by users or tools. Owner of the + * entity must confirm the suggested labels before it is marked as 'Confirmed'. + */ + state?: State; + style?: Style; + tagFQN?: string; + /** + * If true the entity referred to has been soft-deleted. + */ + deleted?: boolean; + /** + * Fully qualified name of the entity instance. For entities such as tables, databases + * fullyQualifiedName is returned in this field. For entities that don't have name hierarchy + * such as `user` and `team` this will be same as the `name` field. + */ + fullyQualifiedName?: string; + /** + * Unique identifier that identifies an entity instance. + */ + id?: string; + /** + * If true the relationship indicated by this entity reference is inherited from the parent + * entity. + */ + inherited?: boolean; + /** + * Entity type/class name - Examples: `database`, `table`, `metrics`, `databaseService`, + * `dashboardService`... + */ + type?: string; +} + +/** + * Label type describes how a tag label was applied. 'Manual' indicates the tag label was + * applied by a person. 'Derived' indicates a tag label was derived using the associated tag + * relationship (see Classification.json for more details). 'Propagated` indicates a tag + * label was propagated from upstream based on lineage. 'Automated' is used when a tool was + * used to determine the tag label. + */ +export enum LabelType { + Automated = "Automated", + Derived = "Derived", + Generated = "Generated", + Manual = "Manual", + Propagated = "Propagated", +} + +/** + * Label is from Tags or Glossary. + */ +export enum TagSource { + Classification = "Classification", + Glossary = "Glossary", +} + +/** + * 'Suggested' state is used when a tag label is suggested by users or tools. Owner of the + * entity must confirm the suggested labels before it is marked as 'Confirmed'. + */ +export enum State { + Confirmed = "Confirmed", + Suggested = "Suggested", +} + +/** + * UI Style is used to associate a color code and/or icon to entity to customize the look of + * that entity in UI. + */ +export interface Style { + /** + * Hex Color Code to mark an entity such as GlossaryTerm, Tag, Domain or Data Product. + */ + color?: string; + /** + * An icon to associate with GlossaryTerm, Tag, Domain or Data Product. + */ + iconURL?: string; +} diff --git a/openmetadata-ui/src/main/resources/ui/src/generated/entity/applications/configuration/external/automatorAppConfig.ts b/openmetadata-ui/src/main/resources/ui/src/generated/entity/applications/configuration/external/automatorAppConfig.ts index 52e920e5e6b..f1d2236b20c 100644 --- a/openmetadata-ui/src/main/resources/ui/src/generated/entity/applications/configuration/external/automatorAppConfig.ts +++ b/openmetadata-ui/src/main/resources/ui/src/generated/entity/applications/configuration/external/automatorAppConfig.ts @@ -114,7 +114,7 @@ export interface Action { * * Tags to remove */ - tags?: TagLabel[]; + tags?: TierElement[]; /** * Application Type */ @@ -146,7 +146,7 @@ export interface Action { /** * tier to apply */ - tier?: TagLabel; + tier?: TierElement; /** * Test Cases to apply */ @@ -201,6 +201,14 @@ export interface Action { * Propagate tier from the parent */ propagateTier?: boolean; + /** + * Number of levels to propagate lineage. If not set, it will propagate to all levels. + */ + propagationDepth?: number; + /** + * List of configurations to stop propagation based on conditions + */ + propagationStopConfigs?: PropagationStopConfig[]; } /** @@ -270,22 +278,68 @@ export enum LabelElement { Propagated = "Propagated", } +/** + * Configuration to stop lineage propagation based on conditions + */ +export interface PropagationStopConfig { + /** + * The metadata attribute to check for stopping propagation + */ + metadataAttribute: MetadataAttribute; + /** + * List of attribute values that will stop propagation when any of them is matched + */ + value: Array; +} + +/** + * The metadata attribute to check for stopping propagation + */ +export enum MetadataAttribute { + Description = "description", + Domain = "domain", + GlossaryTerms = "glossaryTerms", + Owner = "owner", + Tags = "tags", + Tier = "tier", +} + /** * This schema defines the type for labeling an entity with a Tag. * * tier to apply + * + * Domain to apply + * + * This schema defines the EntityReference type used for referencing an entity. + * EntityReference is used for capturing relationships from one entity to another. For + * example, a table has an attribute called database of type EntityReference that captures + * the relationship of a table `belongs to a` database. + * + * Owners to apply + * + * This schema defines the EntityReferenceList type used for referencing an entity. + * EntityReference is used for capturing relationships from one entity to another. For + * example, a table has an attribute called database of type EntityReference that captures + * the relationship of a table `belongs to a` database. */ export interface TagLabel { /** * Description for the tag label. + * + * Optional description of entity. */ description?: string; /** * Display Name that identifies this tag. + * + * Display Name that identifies this entity. */ displayName?: string; /** * Link to the tag resource. + * + * Link to the entity resource. */ href?: string; /** @@ -295,22 +349,48 @@ export interface TagLabel { * label was propagated from upstream based on lineage. 'Automated' is used when a tool was * used to determine the tag label. */ - labelType: LabelTypeEnum; + labelType?: LabelTypeEnum; /** * Name of the tag or glossary term. + * + * Name of the entity instance. */ name?: string; /** * Label is from Tags or Glossary. */ - source: TagSource; + source?: TagSource; /** * 'Suggested' state is used when a tag label is suggested by users or tools. Owner of the * entity must confirm the suggested labels before it is marked as 'Confirmed'. */ - state: State; - style?: Style; - tagFQN: string; + state?: State; + style?: Style; + tagFQN?: string; + /** + * If true the entity referred to has been soft-deleted. + */ + deleted?: boolean; + /** + * Fully qualified name of the entity instance. For entities such as tables, databases + * fullyQualifiedName is returned in this field. For entities that don't have name hierarchy + * such as `user` and `team` this will be same as the `name` field. + */ + fullyQualifiedName?: string; + /** + * Unique identifier that identifies an entity instance. + */ + id?: string; + /** + * If true the relationship indicated by this entity reference is inherited from the parent + * entity. + */ + inherited?: boolean; + /** + * Entity type/class name - Examples: `database`, `table`, `metrics`, `databaseService`, + * `dashboardService`... + */ + type?: string; } /** @@ -360,6 +440,49 @@ export interface Style { iconURL?: string; } +/** + * This schema defines the type for labeling an entity with a Tag. + * + * tier to apply + */ +export interface TierElement { + /** + * Description for the tag label. + */ + description?: string; + /** + * Display Name that identifies this tag. + */ + displayName?: string; + /** + * Link to the tag resource. + */ + href?: string; + /** + * Label type describes how a tag label was applied. 'Manual' indicates the tag label was + * applied by a person. 'Derived' indicates a tag label was derived using the associated tag + * relationship (see Classification.json for more details). 'Propagated` indicates a tag + * label was propagated from upstream based on lineage. 'Automated' is used when a tool was + * used to determine the tag label. + */ + labelType: LabelTypeEnum; + /** + * Name of the tag or glossary term. + */ + name?: string; + /** + * Label is from Tags or Glossary. + */ + source: TagSource; + /** + * 'Suggested' state is used when a tag label is suggested by users or tools. Owner of the + * entity must confirm the suggested labels before it is marked as 'Confirmed'. + */ + state: State; + style?: Style; + tagFQN: string; +} + /** * Minimum set of requirements to get a Test Case request ready */ @@ -372,7 +495,7 @@ export interface TestCaseDefinitions { /** * Tags to apply */ - tags?: TagLabel[]; + tags?: TierElement[]; /** * Fully qualified name of the test definition. */ diff --git a/openmetadata-ui/src/main/resources/ui/src/generated/entity/applications/marketplace/appMarketPlaceDefinition.ts b/openmetadata-ui/src/main/resources/ui/src/generated/entity/applications/marketplace/appMarketPlaceDefinition.ts index 9bd0848dee9..021d1494275 100644 --- a/openmetadata-ui/src/main/resources/ui/src/generated/entity/applications/marketplace/appMarketPlaceDefinition.ts +++ b/openmetadata-ui/src/main/resources/ui/src/generated/entity/applications/marketplace/appMarketPlaceDefinition.ts @@ -146,7 +146,7 @@ export interface AppMarketPlaceDefinition { /** * Tags associated with the entity. */ - tags?: TagLabel[]; + tags?: TagElement[]; /** * Last update time corresponding to the new version of the entity in Unix epoch time * milliseconds. @@ -393,7 +393,7 @@ export interface Action { * * Tags to remove */ - tags?: TagLabel[]; + tags?: TagElement[]; /** * Application Type */ @@ -425,7 +425,7 @@ export interface Action { /** * tier to apply */ - tier?: TagLabel; + tier?: TagElement; /** * Test Cases to apply */ @@ -480,6 +480,14 @@ export interface Action { * Propagate tier from the parent */ propagateTier?: boolean; + /** + * Number of levels to propagate lineage. If not set, it will propagate to all levels. + */ + propagationDepth?: number; + /** + * List of configurations to stop propagation based on conditions + */ + propagationStopConfigs?: PropagationStopConfig[]; } /** @@ -549,22 +557,71 @@ export enum LabelElement { Propagated = "Propagated", } +/** + * Configuration to stop lineage propagation based on conditions + */ +export interface PropagationStopConfig { + /** + * The metadata attribute to check for stopping propagation + */ + metadataAttribute: MetadataAttribute; + /** + * List of attribute values that will stop propagation when any of them is matched + */ + value: Array; +} + +/** + * The metadata attribute to check for stopping propagation + */ +export enum MetadataAttribute { + Description = "description", + Domain = "domain", + GlossaryTerms = "glossaryTerms", + Owner = "owner", + Tags = "tags", + Tier = "tier", +} + /** * This schema defines the type for labeling an entity with a Tag. * * tier to apply + * + * Domain to apply + * + * This schema defines the EntityReference type used for referencing an entity. + * EntityReference is used for capturing relationships from one entity to another. For + * example, a table has an attribute called database of type EntityReference that captures + * the relationship of a table `belongs to a` database. + * + * Owners to apply + * + * This schema defines the EntityReferenceList type used for referencing an entity. + * EntityReference is used for capturing relationships from one entity to another. For + * example, a table has an attribute called database of type EntityReference that captures + * the relationship of a table `belongs to a` database. + * + * Domain the asset belongs to. When not set, the asset inherits the domain from the parent + * it belongs to. */ export interface TagLabel { /** * Description for the tag label. + * + * Optional description of entity. */ description?: string; /** * Display Name that identifies this tag. + * + * Display Name that identifies this entity. */ displayName?: string; /** * Link to the tag resource. + * + * Link to the entity resource. */ href?: string; /** @@ -574,22 +631,48 @@ export interface TagLabel { * label was propagated from upstream based on lineage. 'Automated' is used when a tool was * used to determine the tag label. */ - labelType: LabelTypeEnum; + labelType?: LabelTypeEnum; /** * Name of the tag or glossary term. + * + * Name of the entity instance. */ name?: string; /** * Label is from Tags or Glossary. */ - source: TagSource; + source?: TagSource; /** * 'Suggested' state is used when a tag label is suggested by users or tools. Owner of the * entity must confirm the suggested labels before it is marked as 'Confirmed'. */ - state: State; - style?: Style; - tagFQN: string; + state?: State; + style?: Style; + tagFQN?: string; + /** + * If true the entity referred to has been soft-deleted. + */ + deleted?: boolean; + /** + * Fully qualified name of the entity instance. For entities such as tables, databases + * fullyQualifiedName is returned in this field. For entities that don't have name hierarchy + * such as `user` and `team` this will be same as the `name` field. + */ + fullyQualifiedName?: string; + /** + * Unique identifier that identifies an entity instance. + */ + id?: string; + /** + * If true the relationship indicated by this entity reference is inherited from the parent + * entity. + */ + inherited?: boolean; + /** + * Entity type/class name - Examples: `database`, `table`, `metrics`, `databaseService`, + * `dashboardService`... + */ + type?: string; } /** @@ -639,6 +722,49 @@ export interface Style { iconURL?: string; } +/** + * This schema defines the type for labeling an entity with a Tag. + * + * tier to apply + */ +export interface TagElement { + /** + * Description for the tag label. + */ + description?: string; + /** + * Display Name that identifies this tag. + */ + displayName?: string; + /** + * Link to the tag resource. + */ + href?: string; + /** + * Label type describes how a tag label was applied. 'Manual' indicates the tag label was + * applied by a person. 'Derived' indicates a tag label was derived using the associated tag + * relationship (see Classification.json for more details). 'Propagated` indicates a tag + * label was propagated from upstream based on lineage. 'Automated' is used when a tool was + * used to determine the tag label. + */ + labelType: LabelTypeEnum; + /** + * Name of the tag or glossary term. + */ + name?: string; + /** + * Label is from Tags or Glossary. + */ + source: TagSource; + /** + * 'Suggested' state is used when a tag label is suggested by users or tools. Owner of the + * entity must confirm the suggested labels before it is marked as 'Confirmed'. + */ + state: State; + style?: Style; + tagFQN: string; +} + /** * Minimum set of requirements to get a Test Case request ready */ @@ -651,7 +777,7 @@ export interface TestCaseDefinitions { /** * Tags to apply */ - tags?: TagLabel[]; + tags?: TagElement[]; /** * Fully qualified name of the test definition. */ diff --git a/openmetadata-ui/src/main/resources/ui/src/generated/entity/applications/marketplace/createAppMarketPlaceDefinitionReq.ts b/openmetadata-ui/src/main/resources/ui/src/generated/entity/applications/marketplace/createAppMarketPlaceDefinitionReq.ts index 518badde42a..51309d5d0c7 100644 --- a/openmetadata-ui/src/main/resources/ui/src/generated/entity/applications/marketplace/createAppMarketPlaceDefinitionReq.ts +++ b/openmetadata-ui/src/main/resources/ui/src/generated/entity/applications/marketplace/createAppMarketPlaceDefinitionReq.ts @@ -120,7 +120,7 @@ export interface CreateAppMarketPlaceDefinitionReq { /** * Tags associated with the entity. */ - tags?: TagLabel[]; + tags?: TagElement[]; } /** @@ -354,7 +354,7 @@ export interface Action { * * Tags to remove */ - tags?: TagLabel[]; + tags?: TagElement[]; /** * Application Type */ @@ -386,7 +386,7 @@ export interface Action { /** * tier to apply */ - tier?: TagLabel; + tier?: TagElement; /** * Test Cases to apply */ @@ -441,6 +441,14 @@ export interface Action { * Propagate tier from the parent */ propagateTier?: boolean; + /** + * Number of levels to propagate lineage. If not set, it will propagate to all levels. + */ + propagationDepth?: number; + /** + * List of configurations to stop propagation based on conditions + */ + propagationStopConfigs?: PropagationStopConfig[]; } /** @@ -510,22 +518,68 @@ export enum LabelElement { Propagated = "Propagated", } +/** + * Configuration to stop lineage propagation based on conditions + */ +export interface PropagationStopConfig { + /** + * The metadata attribute to check for stopping propagation + */ + metadataAttribute: MetadataAttribute; + /** + * List of attribute values that will stop propagation when any of them is matched + */ + value: Array; +} + +/** + * The metadata attribute to check for stopping propagation + */ +export enum MetadataAttribute { + Description = "description", + Domain = "domain", + GlossaryTerms = "glossaryTerms", + Owner = "owner", + Tags = "tags", + Tier = "tier", +} + /** * This schema defines the type for labeling an entity with a Tag. * * tier to apply + * + * Domain to apply + * + * This schema defines the EntityReference type used for referencing an entity. + * EntityReference is used for capturing relationships from one entity to another. For + * example, a table has an attribute called database of type EntityReference that captures + * the relationship of a table `belongs to a` database. + * + * Owners to apply + * + * This schema defines the EntityReferenceList type used for referencing an entity. + * EntityReference is used for capturing relationships from one entity to another. For + * example, a table has an attribute called database of type EntityReference that captures + * the relationship of a table `belongs to a` database. */ export interface TagLabel { /** * Description for the tag label. + * + * Optional description of entity. */ description?: string; /** * Display Name that identifies this tag. + * + * Display Name that identifies this entity. */ displayName?: string; /** * Link to the tag resource. + * + * Link to the entity resource. */ href?: string; /** @@ -535,22 +589,48 @@ export interface TagLabel { * label was propagated from upstream based on lineage. 'Automated' is used when a tool was * used to determine the tag label. */ - labelType: LabelTypeEnum; + labelType?: LabelTypeEnum; /** * Name of the tag or glossary term. + * + * Name of the entity instance. */ name?: string; /** * Label is from Tags or Glossary. */ - source: TagSource; + source?: TagSource; /** * 'Suggested' state is used when a tag label is suggested by users or tools. Owner of the * entity must confirm the suggested labels before it is marked as 'Confirmed'. */ - state: State; - style?: Style; - tagFQN: string; + state?: State; + style?: Style; + tagFQN?: string; + /** + * If true the entity referred to has been soft-deleted. + */ + deleted?: boolean; + /** + * Fully qualified name of the entity instance. For entities such as tables, databases + * fullyQualifiedName is returned in this field. For entities that don't have name hierarchy + * such as `user` and `team` this will be same as the `name` field. + */ + fullyQualifiedName?: string; + /** + * Unique identifier that identifies an entity instance. + */ + id?: string; + /** + * If true the relationship indicated by this entity reference is inherited from the parent + * entity. + */ + inherited?: boolean; + /** + * Entity type/class name - Examples: `database`, `table`, `metrics`, `databaseService`, + * `dashboardService`... + */ + type?: string; } /** @@ -600,6 +680,49 @@ export interface Style { iconURL?: string; } +/** + * This schema defines the type for labeling an entity with a Tag. + * + * tier to apply + */ +export interface TagElement { + /** + * Description for the tag label. + */ + description?: string; + /** + * Display Name that identifies this tag. + */ + displayName?: string; + /** + * Link to the tag resource. + */ + href?: string; + /** + * Label type describes how a tag label was applied. 'Manual' indicates the tag label was + * applied by a person. 'Derived' indicates a tag label was derived using the associated tag + * relationship (see Classification.json for more details). 'Propagated` indicates a tag + * label was propagated from upstream based on lineage. 'Automated' is used when a tool was + * used to determine the tag label. + */ + labelType: LabelTypeEnum; + /** + * Name of the tag or glossary term. + */ + name?: string; + /** + * Label is from Tags or Glossary. + */ + source: TagSource; + /** + * 'Suggested' state is used when a tag label is suggested by users or tools. Owner of the + * entity must confirm the suggested labels before it is marked as 'Confirmed'. + */ + state: State; + style?: Style; + tagFQN: string; +} + /** * Minimum set of requirements to get a Test Case request ready */ @@ -612,7 +735,7 @@ export interface TestCaseDefinitions { /** * Tags to apply */ - tags?: TagLabel[]; + tags?: TagElement[]; /** * Fully qualified name of the test definition. */ diff --git a/openmetadata-ui/src/main/resources/ui/src/generated/entity/services/ingestionPipelines/ingestionPipeline.ts b/openmetadata-ui/src/main/resources/ui/src/generated/entity/services/ingestionPipelines/ingestionPipeline.ts index 593bfdd58bc..a401e775159 100644 --- a/openmetadata-ui/src/main/resources/ui/src/generated/entity/services/ingestionPipelines/ingestionPipeline.ts +++ b/openmetadata-ui/src/main/resources/ui/src/generated/entity/services/ingestionPipelines/ingestionPipeline.ts @@ -1525,7 +1525,7 @@ export interface Action { * * Tags to remove */ - tags?: TagLabel[]; + tags?: TierElement[]; /** * Application Type */ @@ -1557,7 +1557,7 @@ export interface Action { /** * tier to apply */ - tier?: TagLabel; + tier?: TierElement; /** * Test Cases to apply */ @@ -1612,6 +1612,14 @@ export interface Action { * Propagate tier from the parent */ propagateTier?: boolean; + /** + * Number of levels to propagate lineage. If not set, it will propagate to all levels. + */ + propagationDepth?: number; + /** + * List of configurations to stop propagation based on conditions + */ + propagationStopConfigs?: PropagationStopConfig[]; } /** @@ -1623,22 +1631,80 @@ export enum LabelElement { Propagated = "Propagated", } +/** + * Configuration to stop lineage propagation based on conditions + */ +export interface PropagationStopConfig { + /** + * The metadata attribute to check for stopping propagation + */ + metadataAttribute: MetadataAttribute; + /** + * List of attribute values that will stop propagation when any of them is matched + */ + value: Array; +} + +/** + * The metadata attribute to check for stopping propagation + */ +export enum MetadataAttribute { + Description = "description", + Domain = "domain", + GlossaryTerms = "glossaryTerms", + Owner = "owner", + Tags = "tags", + Tier = "tier", +} + /** * This schema defines the type for labeling an entity with a Tag. * * tier to apply + * + * Domain the asset belongs to. When not set, the asset inherits the domain from the parent + * it belongs to. + * + * This schema defines the EntityReference type used for referencing an entity. + * EntityReference is used for capturing relationships from one entity to another. For + * example, a table has an attribute called database of type EntityReference that captures + * the relationship of a table `belongs to a` database. + * + * Followers of this entity. + * + * This schema defines the EntityReferenceList type used for referencing an entity. + * EntityReference is used for capturing relationships from one entity to another. For + * example, a table has an attribute called database of type EntityReference that captures + * the relationship of a table `belongs to a` database. + * + * The ingestion agent responsible for executing the ingestion pipeline. + * + * The processing engine responsible for executing the ingestion pipeline logic. + * + * Link to the service (such as database, messaging, storage services, etc. for which this + * ingestion pipeline ingests the metadata from. + * + * Domain to apply + * + * Service to be modified */ export interface TagLabel { /** * Description for the tag label. + * + * Optional description of entity. */ description?: string; /** * Display Name that identifies this tag. + * + * Display Name that identifies this entity. */ displayName?: string; /** * Link to the tag resource. + * + * Link to the entity resource. */ href?: string; /** @@ -1648,22 +1714,48 @@ export interface TagLabel { * label was propagated from upstream based on lineage. 'Automated' is used when a tool was * used to determine the tag label. */ - labelType: LabelTypeEnum; + labelType?: LabelTypeEnum; /** * Name of the tag or glossary term. + * + * Name of the entity instance. */ name?: string; /** * Label is from Tags or Glossary. */ - source: TagSource; + source?: TagSource; /** * 'Suggested' state is used when a tag label is suggested by users or tools. Owner of the * entity must confirm the suggested labels before it is marked as 'Confirmed'. */ - state: State; - style?: Style; - tagFQN: string; + state?: State; + style?: Style; + tagFQN?: string; + /** + * If true the entity referred to has been soft-deleted. + */ + deleted?: boolean; + /** + * Fully qualified name of the entity instance. For entities such as tables, databases + * fullyQualifiedName is returned in this field. For entities that don't have name hierarchy + * such as `user` and `team` this will be same as the `name` field. + */ + fullyQualifiedName?: string; + /** + * Unique identifier that identifies an entity instance. + */ + id?: string; + /** + * If true the relationship indicated by this entity reference is inherited from the parent + * entity. + */ + inherited?: boolean; + /** + * Entity type/class name - Examples: `database`, `table`, `metrics`, `databaseService`, + * `dashboardService`... + */ + type?: string; } /** @@ -1713,6 +1805,49 @@ export interface Style { iconURL?: string; } +/** + * This schema defines the type for labeling an entity with a Tag. + * + * tier to apply + */ +export interface TierElement { + /** + * Description for the tag label. + */ + description?: string; + /** + * Display Name that identifies this tag. + */ + displayName?: string; + /** + * Link to the tag resource. + */ + href?: string; + /** + * Label type describes how a tag label was applied. 'Manual' indicates the tag label was + * applied by a person. 'Derived' indicates a tag label was derived using the associated tag + * relationship (see Classification.json for more details). 'Propagated` indicates a tag + * label was propagated from upstream based on lineage. 'Automated' is used when a tool was + * used to determine the tag label. + */ + labelType: LabelTypeEnum; + /** + * Name of the tag or glossary term. + */ + name?: string; + /** + * Label is from Tags or Glossary. + */ + source: TagSource; + /** + * 'Suggested' state is used when a tag label is suggested by users or tools. Owner of the + * entity must confirm the suggested labels before it is marked as 'Confirmed'. + */ + state: State; + style?: Style; + tagFQN: string; +} + /** * Minimum set of requirements to get a Test Case request ready */ @@ -1725,7 +1860,7 @@ export interface TestCaseDefinitions { /** * Tags to apply */ - tags?: TagLabel[]; + tags?: TierElement[]; /** * Fully qualified name of the test definition. */ @@ -2396,11 +2531,11 @@ export interface ReverseIngestionConfig { /** * Added tags to be applied */ - addedTags?: TagLabel[]; + addedTags?: TierElement[]; /** * Removed tags of the entity */ - removedTags?: TagLabel[]; + removedTags?: TierElement[]; } /** diff --git a/openmetadata-ui/src/main/resources/ui/src/generated/metadataIngestion/application.ts b/openmetadata-ui/src/main/resources/ui/src/generated/metadataIngestion/application.ts index fe9d4efa806..08aed4b5c20 100644 --- a/openmetadata-ui/src/main/resources/ui/src/generated/metadataIngestion/application.ts +++ b/openmetadata-ui/src/main/resources/ui/src/generated/metadataIngestion/application.ts @@ -264,7 +264,7 @@ export interface Action { * * Tags to remove */ - tags?: TagLabel[]; + tags?: TierElement[]; /** * Application Type */ @@ -296,7 +296,7 @@ export interface Action { /** * tier to apply */ - tier?: TagLabel; + tier?: TierElement; /** * Test Cases to apply */ @@ -351,6 +351,14 @@ export interface Action { * Propagate tier from the parent */ propagateTier?: boolean; + /** + * Number of levels to propagate lineage. If not set, it will propagate to all levels. + */ + propagationDepth?: number; + /** + * List of configurations to stop propagation based on conditions + */ + propagationStopConfigs?: PropagationStopConfig[]; } /** @@ -420,22 +428,68 @@ export enum LabelElement { Propagated = "Propagated", } +/** + * Configuration to stop lineage propagation based on conditions + */ +export interface PropagationStopConfig { + /** + * The metadata attribute to check for stopping propagation + */ + metadataAttribute: MetadataAttribute; + /** + * List of attribute values that will stop propagation when any of them is matched + */ + value: Array; +} + +/** + * The metadata attribute to check for stopping propagation + */ +export enum MetadataAttribute { + Description = "description", + Domain = "domain", + GlossaryTerms = "glossaryTerms", + Owner = "owner", + Tags = "tags", + Tier = "tier", +} + /** * This schema defines the type for labeling an entity with a Tag. * * tier to apply + * + * Domain to apply + * + * This schema defines the EntityReference type used for referencing an entity. + * EntityReference is used for capturing relationships from one entity to another. For + * example, a table has an attribute called database of type EntityReference that captures + * the relationship of a table `belongs to a` database. + * + * Owners to apply + * + * This schema defines the EntityReferenceList type used for referencing an entity. + * EntityReference is used for capturing relationships from one entity to another. For + * example, a table has an attribute called database of type EntityReference that captures + * the relationship of a table `belongs to a` database. */ export interface TagLabel { /** * Description for the tag label. + * + * Optional description of entity. */ description?: string; /** * Display Name that identifies this tag. + * + * Display Name that identifies this entity. */ displayName?: string; /** * Link to the tag resource. + * + * Link to the entity resource. */ href?: string; /** @@ -445,22 +499,48 @@ export interface TagLabel { * label was propagated from upstream based on lineage. 'Automated' is used when a tool was * used to determine the tag label. */ - labelType: LabelTypeEnum; + labelType?: LabelTypeEnum; /** * Name of the tag or glossary term. + * + * Name of the entity instance. */ name?: string; /** * Label is from Tags or Glossary. */ - source: TagSource; + source?: TagSource; /** * 'Suggested' state is used when a tag label is suggested by users or tools. Owner of the * entity must confirm the suggested labels before it is marked as 'Confirmed'. */ - state: State; - style?: Style; - tagFQN: string; + state?: State; + style?: Style; + tagFQN?: string; + /** + * If true the entity referred to has been soft-deleted. + */ + deleted?: boolean; + /** + * Fully qualified name of the entity instance. For entities such as tables, databases + * fullyQualifiedName is returned in this field. For entities that don't have name hierarchy + * such as `user` and `team` this will be same as the `name` field. + */ + fullyQualifiedName?: string; + /** + * Unique identifier that identifies an entity instance. + */ + id?: string; + /** + * If true the relationship indicated by this entity reference is inherited from the parent + * entity. + */ + inherited?: boolean; + /** + * Entity type/class name - Examples: `database`, `table`, `metrics`, `databaseService`, + * `dashboardService`... + */ + type?: string; } /** @@ -510,6 +590,49 @@ export interface Style { iconURL?: string; } +/** + * This schema defines the type for labeling an entity with a Tag. + * + * tier to apply + */ +export interface TierElement { + /** + * Description for the tag label. + */ + description?: string; + /** + * Display Name that identifies this tag. + */ + displayName?: string; + /** + * Link to the tag resource. + */ + href?: string; + /** + * Label type describes how a tag label was applied. 'Manual' indicates the tag label was + * applied by a person. 'Derived' indicates a tag label was derived using the associated tag + * relationship (see Classification.json for more details). 'Propagated` indicates a tag + * label was propagated from upstream based on lineage. 'Automated' is used when a tool was + * used to determine the tag label. + */ + labelType: LabelTypeEnum; + /** + * Name of the tag or glossary term. + */ + name?: string; + /** + * Label is from Tags or Glossary. + */ + source: TagSource; + /** + * 'Suggested' state is used when a tag label is suggested by users or tools. Owner of the + * entity must confirm the suggested labels before it is marked as 'Confirmed'. + */ + state: State; + style?: Style; + tagFQN: string; +} + /** * Minimum set of requirements to get a Test Case request ready */ @@ -522,7 +645,7 @@ export interface TestCaseDefinitions { /** * Tags to apply */ - tags?: TagLabel[]; + tags?: TierElement[]; /** * Fully qualified name of the test definition. */ diff --git a/openmetadata-ui/src/main/resources/ui/src/generated/metadataIngestion/applicationPipeline.ts b/openmetadata-ui/src/main/resources/ui/src/generated/metadataIngestion/applicationPipeline.ts index 1075aadcb8f..020bb4cc2d9 100644 --- a/openmetadata-ui/src/main/resources/ui/src/generated/metadataIngestion/applicationPipeline.ts +++ b/openmetadata-ui/src/main/resources/ui/src/generated/metadataIngestion/applicationPipeline.ts @@ -253,7 +253,7 @@ export interface Action { * * Tags to remove */ - tags?: TagLabel[]; + tags?: TierElement[]; /** * Application Type */ @@ -285,7 +285,7 @@ export interface Action { /** * tier to apply */ - tier?: TagLabel; + tier?: TierElement; /** * Test Cases to apply */ @@ -340,6 +340,14 @@ export interface Action { * Propagate tier from the parent */ propagateTier?: boolean; + /** + * Number of levels to propagate lineage. If not set, it will propagate to all levels. + */ + propagationDepth?: number; + /** + * List of configurations to stop propagation based on conditions + */ + propagationStopConfigs?: PropagationStopConfig[]; } /** @@ -409,22 +417,68 @@ export enum LabelElement { Propagated = "Propagated", } +/** + * Configuration to stop lineage propagation based on conditions + */ +export interface PropagationStopConfig { + /** + * The metadata attribute to check for stopping propagation + */ + metadataAttribute: MetadataAttribute; + /** + * List of attribute values that will stop propagation when any of them is matched + */ + value: Array; +} + +/** + * The metadata attribute to check for stopping propagation + */ +export enum MetadataAttribute { + Description = "description", + Domain = "domain", + GlossaryTerms = "glossaryTerms", + Owner = "owner", + Tags = "tags", + Tier = "tier", +} + /** * This schema defines the type for labeling an entity with a Tag. * * tier to apply + * + * Domain to apply + * + * This schema defines the EntityReference type used for referencing an entity. + * EntityReference is used for capturing relationships from one entity to another. For + * example, a table has an attribute called database of type EntityReference that captures + * the relationship of a table `belongs to a` database. + * + * Owners to apply + * + * This schema defines the EntityReferenceList type used for referencing an entity. + * EntityReference is used for capturing relationships from one entity to another. For + * example, a table has an attribute called database of type EntityReference that captures + * the relationship of a table `belongs to a` database. */ export interface TagLabel { /** * Description for the tag label. + * + * Optional description of entity. */ description?: string; /** * Display Name that identifies this tag. + * + * Display Name that identifies this entity. */ displayName?: string; /** * Link to the tag resource. + * + * Link to the entity resource. */ href?: string; /** @@ -434,22 +488,48 @@ export interface TagLabel { * label was propagated from upstream based on lineage. 'Automated' is used when a tool was * used to determine the tag label. */ - labelType: LabelTypeEnum; + labelType?: LabelTypeEnum; /** * Name of the tag or glossary term. + * + * Name of the entity instance. */ name?: string; /** * Label is from Tags or Glossary. */ - source: TagSource; + source?: TagSource; /** * 'Suggested' state is used when a tag label is suggested by users or tools. Owner of the * entity must confirm the suggested labels before it is marked as 'Confirmed'. */ - state: State; - style?: Style; - tagFQN: string; + state?: State; + style?: Style; + tagFQN?: string; + /** + * If true the entity referred to has been soft-deleted. + */ + deleted?: boolean; + /** + * Fully qualified name of the entity instance. For entities such as tables, databases + * fullyQualifiedName is returned in this field. For entities that don't have name hierarchy + * such as `user` and `team` this will be same as the `name` field. + */ + fullyQualifiedName?: string; + /** + * Unique identifier that identifies an entity instance. + */ + id?: string; + /** + * If true the relationship indicated by this entity reference is inherited from the parent + * entity. + */ + inherited?: boolean; + /** + * Entity type/class name - Examples: `database`, `table`, `metrics`, `databaseService`, + * `dashboardService`... + */ + type?: string; } /** @@ -499,6 +579,49 @@ export interface Style { iconURL?: string; } +/** + * This schema defines the type for labeling an entity with a Tag. + * + * tier to apply + */ +export interface TierElement { + /** + * Description for the tag label. + */ + description?: string; + /** + * Display Name that identifies this tag. + */ + displayName?: string; + /** + * Link to the tag resource. + */ + href?: string; + /** + * Label type describes how a tag label was applied. 'Manual' indicates the tag label was + * applied by a person. 'Derived' indicates a tag label was derived using the associated tag + * relationship (see Classification.json for more details). 'Propagated` indicates a tag + * label was propagated from upstream based on lineage. 'Automated' is used when a tool was + * used to determine the tag label. + */ + labelType: LabelTypeEnum; + /** + * Name of the tag or glossary term. + */ + name?: string; + /** + * Label is from Tags or Glossary. + */ + source: TagSource; + /** + * 'Suggested' state is used when a tag label is suggested by users or tools. Owner of the + * entity must confirm the suggested labels before it is marked as 'Confirmed'. + */ + state: State; + style?: Style; + tagFQN: string; +} + /** * Minimum set of requirements to get a Test Case request ready */ @@ -511,7 +634,7 @@ export interface TestCaseDefinitions { /** * Tags to apply */ - tags?: TagLabel[]; + tags?: TierElement[]; /** * Fully qualified name of the test definition. */ diff --git a/openmetadata-ui/src/main/resources/ui/src/generated/metadataIngestion/workflow.ts b/openmetadata-ui/src/main/resources/ui/src/generated/metadataIngestion/workflow.ts index 4f2886d5dcd..b9d7bd2ee13 100644 --- a/openmetadata-ui/src/main/resources/ui/src/generated/metadataIngestion/workflow.ts +++ b/openmetadata-ui/src/main/resources/ui/src/generated/metadataIngestion/workflow.ts @@ -4709,7 +4709,7 @@ export interface Action { * * Tags to remove */ - tags?: TagLabel[]; + tags?: TierElement[]; /** * Application Type */ @@ -4741,7 +4741,7 @@ export interface Action { /** * tier to apply */ - tier?: TagLabel; + tier?: TierElement; /** * Test Cases to apply */ @@ -4796,6 +4796,14 @@ export interface Action { * Propagate tier from the parent */ propagateTier?: boolean; + /** + * Number of levels to propagate lineage. If not set, it will propagate to all levels. + */ + propagationDepth?: number; + /** + * List of configurations to stop propagation based on conditions + */ + propagationStopConfigs?: PropagationStopConfig[]; } /** @@ -4867,22 +4875,70 @@ export enum LabelElement { Propagated = "Propagated", } +/** + * Configuration to stop lineage propagation based on conditions + */ +export interface PropagationStopConfig { + /** + * The metadata attribute to check for stopping propagation + */ + metadataAttribute: MetadataAttribute; + /** + * List of attribute values that will stop propagation when any of them is matched + */ + value: Array; +} + +/** + * The metadata attribute to check for stopping propagation + */ +export enum MetadataAttribute { + Description = "description", + Domain = "domain", + GlossaryTerms = "glossaryTerms", + Owner = "owner", + Tags = "tags", + Tier = "tier", +} + /** * This schema defines the type for labeling an entity with a Tag. * * tier to apply + * + * Domain to apply + * + * This schema defines the EntityReference type used for referencing an entity. + * EntityReference is used for capturing relationships from one entity to another. For + * example, a table has an attribute called database of type EntityReference that captures + * the relationship of a table `belongs to a` database. + * + * Owners to apply + * + * This schema defines the EntityReferenceList type used for referencing an entity. + * EntityReference is used for capturing relationships from one entity to another. For + * example, a table has an attribute called database of type EntityReference that captures + * the relationship of a table `belongs to a` database. + * + * Service to be modified */ export interface TagLabel { /** * Description for the tag label. + * + * Optional description of entity. */ description?: string; /** * Display Name that identifies this tag. + * + * Display Name that identifies this entity. */ displayName?: string; /** * Link to the tag resource. + * + * Link to the entity resource. */ href?: string; /** @@ -4892,22 +4948,48 @@ export interface TagLabel { * label was propagated from upstream based on lineage. 'Automated' is used when a tool was * used to determine the tag label. */ - labelType: LabelTypeEnum; + labelType?: LabelTypeEnum; /** * Name of the tag or glossary term. + * + * Name of the entity instance. */ name?: string; /** * Label is from Tags or Glossary. */ - source: TagSource; + source?: TagSource; /** * 'Suggested' state is used when a tag label is suggested by users or tools. Owner of the * entity must confirm the suggested labels before it is marked as 'Confirmed'. */ - state: State; - style?: Style; - tagFQN: string; + state?: State; + style?: Style; + tagFQN?: string; + /** + * If true the entity referred to has been soft-deleted. + */ + deleted?: boolean; + /** + * Fully qualified name of the entity instance. For entities such as tables, databases + * fullyQualifiedName is returned in this field. For entities that don't have name hierarchy + * such as `user` and `team` this will be same as the `name` field. + */ + fullyQualifiedName?: string; + /** + * Unique identifier that identifies an entity instance. + */ + id?: string; + /** + * If true the relationship indicated by this entity reference is inherited from the parent + * entity. + */ + inherited?: boolean; + /** + * Entity type/class name - Examples: `database`, `table`, `metrics`, `databaseService`, + * `dashboardService`... + */ + type?: string; } /** @@ -4957,6 +5039,49 @@ export interface Style { iconURL?: string; } +/** + * This schema defines the type for labeling an entity with a Tag. + * + * tier to apply + */ +export interface TierElement { + /** + * Description for the tag label. + */ + description?: string; + /** + * Display Name that identifies this tag. + */ + displayName?: string; + /** + * Link to the tag resource. + */ + href?: string; + /** + * Label type describes how a tag label was applied. 'Manual' indicates the tag label was + * applied by a person. 'Derived' indicates a tag label was derived using the associated tag + * relationship (see Classification.json for more details). 'Propagated` indicates a tag + * label was propagated from upstream based on lineage. 'Automated' is used when a tool was + * used to determine the tag label. + */ + labelType: LabelTypeEnum; + /** + * Name of the tag or glossary term. + */ + name?: string; + /** + * Label is from Tags or Glossary. + */ + source: TagSource; + /** + * 'Suggested' state is used when a tag label is suggested by users or tools. Owner of the + * entity must confirm the suggested labels before it is marked as 'Confirmed'. + */ + state: State; + style?: Style; + tagFQN: string; +} + /** * Minimum set of requirements to get a Test Case request ready */ @@ -4969,7 +5094,7 @@ export interface TestCaseDefinitions { /** * Tags to apply */ - tags?: TagLabel[]; + tags?: TierElement[]; /** * Fully qualified name of the test definition. */ @@ -5438,11 +5563,11 @@ export interface ReverseIngestionConfig { /** * Added tags to be applied */ - addedTags?: TagLabel[]; + addedTags?: TierElement[]; /** * Removed tags of the entity */ - removedTags?: TagLabel[]; + removedTags?: TierElement[]; } /**