@gradientedge/cdk-utils 10.0.0 → 10.2.0

package/dist/src/lib/azure/common/constants.d.ts

@@ -1,6 +1,7 @@
 export declare enum AzureRemoteBackend {
-    local = "local",
-    azurerm = "azurerm"
+    azurerm = "azurerm",
+    pulumi = "pulumi",
+    local = "local"
 }
 /**
  * List of Azure resources that excludes tags

package/dist/src/lib/azure/common/constants.js

@@ -1,7 +1,8 @@
 export var AzureRemoteBackend;
 (function (AzureRemoteBackend) {
-    AzureRemoteBackend["local"] = "local";
     AzureRemoteBackend["azurerm"] = "azurerm";
+    AzureRemoteBackend["pulumi"] = "pulumi";
+    AzureRemoteBackend["local"] = "local";
 })(AzureRemoteBackend || (AzureRemoteBackend = {}));
 /**
  * List of Azure resources that excludes tags

package/dist/src/lib/azure/common/construct.d.ts

@@ -1,10 +1,29 @@
-import { TerraformStack } from 'cdktf';
-import { Construct } from 'constructs';
-import { AzureApiManagementManager, AzureAppConfigurationManager, AzureAppServiceManager, AzureApplicationInsightsManager, AzureCosmosDbManager, AzureDnsManager, AzureEventgridManager, AzureFunctionManager, AzureKeyVaultManager, AzureLogAnalyticsWorkspaceManager, AzureMonitorManager, AzureRedisManager, AzureResourceGroupManager, AzureServicebusManager, AzureStorageManager } from '../services/index.js';
+import { ComponentResource, ComponentResourceOptions } from '@pulumi/pulumi';
+import { AzureApiManagementManager, AzureAppConfigurationManager, AzureAppServiceManager, AzureApplicationInsightsManager, AzureCosmosDbManager, AzureDnsManager, AzureEventgridManager, AzureFunctionManager, AzureKeyVaultManager, AzureOperationalInsightsManager, AzureMonitorManager, AzureRedisManager, AzureResourceGroupManager, AzureServicebusManager, AzureStorageManager } from '../services/index.js';
 import { AzureResourceNameFormatter } from './resource-name-formatter.js';
 import { CommonAzureStackProps } from './types.js';
-export declare class CommonAzureConstruct extends TerraformStack {
+/**
+ * @classdesc Common Azure construct to use as a base for all higher level constructs using Pulumi
+ * - Provides manager instances for all Azure services
+ * - Handles resource naming conventions
+ * - Manages common properties and utilities
+ * @example
+ * ```typescript
+ * import { CommonAzureConstruct } from '@gradientedge/cdk-utils'
+ *
+ * class CustomConstruct extends CommonAzureConstruct {
+ *   constructor(name: string, props: CommonAzureStackProps) {
+ *     super(name, props)
+ *     // provision resources using this.resourceGroupManager, etc.
+ *   }
+ * }
+ * ```
+ */
+export declare class CommonAzureConstruct extends ComponentResource {
     props: CommonAzureStackProps;
+    options?: ComponentResourceOptions;
+    id: string;
+    fullyQualifiedDomainName: string;
     apiManagementManager: AzureApiManagementManager;
     appConfigurationManager: AzureAppConfigurationManager;
     appServiceManager: AzureAppServiceManager;
@@ -12,25 +31,20 @@ export declare class CommonAzureConstruct extends TerraformStack {
     cosmosDbManager: AzureCosmosDbManager;
     dnsManager: AzureDnsManager;
     eventgridManager: AzureEventgridManager;
-    fullyQualifiedDomainName: string;
-    functiontManager: AzureFunctionManager;
-    id: string;
+    functionManager: AzureFunctionManager;
     keyVaultManager: AzureKeyVaultManager;
-    logAnalyticsWorkspaceManager: AzureLogAnalyticsWorkspaceManager;
+    operationalInsightsManager: AzureOperationalInsightsManager;
     monitorManager: AzureMonitorManager;
     redisManager: AzureRedisManager;
     resourceGroupManager: AzureResourceGroupManager;
     resourceNameFormatter: AzureResourceNameFormatter;
     servicebusManager: AzureServicebusManager;
     storageManager: AzureStorageManager;
-    tenantId: string;
-    constructor(scope: Construct, id: string, props: CommonAzureStackProps);
+    constructor(name: string, props: CommonAzureStackProps, options?: ComponentResourceOptions);
     /**
      * @summary Determine the fully qualified domain name based on domainName & subDomain
      */
     protected determineFullyQualifiedDomain(): void;
-    protected determineRemoteBackend(): void;
-    protected determineTenantId(): void;
     /**
      * @summary Utility method to determine if the initialisation is in development (dev) stage
      * This is determined by the stage property injected via cdk context

package/dist/src/lib/azure/common/construct.js

@@ -1,12 +1,27 @@
-import { DataAzurermClientConfig } from '@cdktf/provider-azurerm/lib/data-azurerm-client-config/index.js';
-import { AzurermProvider } from '@cdktf/provider-azurerm/lib/provider/index.js';
-import { AzurermBackend, TerraformStack } from 'cdktf';
-import { Provider } from 'cdktf-local-exec';
+import { ComponentResource } from '@pulumi/pulumi';
 import { isDevStage, isPrdStage, isTestStage, isUatStage } from '../../common/index.js';
-import { AzureApiManagementManager, AzureAppConfigurationManager, AzureAppServiceManager, AzureApplicationInsightsManager, AzureCosmosDbManager, AzureDnsManager, AzureEventgridManager, AzureFunctionManager, AzureKeyVaultManager, AzureLogAnalyticsWorkspaceManager, AzureMonitorManager, AzureRedisManager, AzureResourceGroupManager, AzureServicebusManager, AzureStorageManager, } from '../services/index.js';
-import { AzureRemoteBackend } from './constants.js';
+import { AzureApiManagementManager, AzureAppConfigurationManager, AzureAppServiceManager, AzureApplicationInsightsManager, AzureCosmosDbManager, AzureDnsManager, AzureEventgridManager, AzureFunctionManager, AzureKeyVaultManager, AzureOperationalInsightsManager, AzureMonitorManager, AzureRedisManager, AzureResourceGroupManager, AzureServicebusManager, AzureStorageManager, } from '../services/index.js';
 import { AzureResourceNameFormatter } from './resource-name-formatter.js';
-export class CommonAzureConstruct extends TerraformStack {
+/**
+ * @classdesc Common Azure construct to use as a base for all higher level constructs using Pulumi
+ * - Provides manager instances for all Azure services
+ * - Handles resource naming conventions
+ * - Manages common properties and utilities
+ * @example
+ * ```typescript
+ * import { CommonAzureConstruct } from '@gradientedge/cdk-utils'
+ *
+ * class CustomConstruct extends CommonAzureConstruct {
+ *   constructor(name: string, props: CommonAzureStackProps) {
+ *     super(name, props)
+ *     // provision resources using this.resourceGroupManager, etc.
+ *   }
+ * }
+ * ```
+ */
+export class CommonAzureConstruct extends ComponentResource {
+    id;
+    fullyQualifiedDomainName;
     apiManagementManager;
     appConfigurationManager;
     appServiceManager;
@@ -14,22 +29,20 @@ export class CommonAzureConstruct extends TerraformStack {
     cosmosDbManager;
     dnsManager;
     eventgridManager;
-    fullyQualifiedDomainName;
-    functiontManager;
-    id;
+    functionManager;
     keyVaultManager;
-    logAnalyticsWorkspaceManager;
+    operationalInsightsManager;
     monitorManager;
     redisManager;
     resourceGroupManager;
     resourceNameFormatter;
     servicebusManager;
     storageManager;
-    tenantId;
-    constructor(scope, id, props) {
-        super(scope, id);
+    constructor(name, props, options) {
+        super(`custom:azure:Construct:${name}`, name, props, options);
         this.props = props;
-        this.id = id;
+        this.options = options;
+        this.id = name;
         this.apiManagementManager = new AzureApiManagementManager();
         this.appConfigurationManager = new AzureAppConfigurationManager();
         this.appServiceManager = new AzureAppServiceManager();
@@ -37,20 +50,16 @@ export class CommonAzureConstruct extends TerraformStack {
         this.cosmosDbManager = new AzureCosmosDbManager();
         this.dnsManager = new AzureDnsManager();
         this.eventgridManager = new AzureEventgridManager();
-        this.functiontManager = new AzureFunctionManager();
+        this.functionManager = new AzureFunctionManager();
         this.keyVaultManager = new AzureKeyVaultManager();
-        this.logAnalyticsWorkspaceManager = new AzureLogAnalyticsWorkspaceManager();
+        this.operationalInsightsManager = new AzureOperationalInsightsManager();
         this.monitorManager = new AzureMonitorManager();
         this.redisManager = new AzureRedisManager();
         this.resourceGroupManager = new AzureResourceGroupManager();
-        this.resourceNameFormatter = new AzureResourceNameFormatter(this, `${id}-rnf`, props);
+        this.resourceNameFormatter = new AzureResourceNameFormatter(props);
         this.servicebusManager = new AzureServicebusManager();
         this.storageManager = new AzureStorageManager();
         this.determineFullyQualifiedDomain();
-        this.determineRemoteBackend();
-        this.determineTenantId();
-        new AzurermProvider(this, `${this.id}-provider`, this.props);
-        new Provider(this, `${this.id}-local-exec-provider`);
     }
     /**
      * @summary Determine the fully qualified domain name based on domainName & subDomain
@@ -60,29 +69,6 @@ export class CommonAzureConstruct extends TerraformStack {
             ? `${this.props.subDomain}.${this.props.domainName}`
             : this.props.domainName;
     }
-    determineRemoteBackend() {
-        const debug = this.node.tryGetContext('debug');
-        switch (this.props.remoteBackend?.type) {
-            case AzureRemoteBackend.azurerm:
-                new AzurermBackend(this, {
-                    storageAccountName: this.props.remoteBackend.storageAccountName,
-                    containerName: this.props.remoteBackend.containerName,
-                    key: `${this.id}`,
-                    subscriptionId: this.props.subscriptionId,
-                    resourceGroupName: this.props.remoteBackend.resourceGroupName,
-                });
-                break;
-            case AzureRemoteBackend.local:
-                if (debug)
-                    console.debug(`Using local backend for ${this.id}`);
-                break;
-            default:
-                break;
-        }
-    }
-    determineTenantId() {
-        this.tenantId = new DataAzurermClientConfig(this, 'current', {}).tenantId;
-    }
     /**
      * @summary Utility method to determine if the initialisation is in development (dev) stage
      * This is determined by the stage property injected via cdk context

package/dist/src/lib/azure/common/resource-name-formatter.d.ts

@@ -1,13 +1,18 @@
-import { Construct } from 'constructs';
 import { AzureResourceNameFormatterProps, CommonAzureStackProps } from '../index.js';
-export declare class AzureResourceNameFormatter extends Construct {
+/**
+ * @classdesc Formats Azure resource names according to naming conventions
+ * - Applies global/resource prefixes and suffixes
+ * - Automatically appends stage to resource names
+ * - Supports per-resource customization via options
+ */
+export declare class AzureResourceNameFormatter {
     props: CommonAzureStackProps;
-    constructor(parent: Construct, id: string, props: CommonAzureStackProps);
+    constructor(props: CommonAzureStackProps);
     /**
      * @summary Helper method to format azure resource name based on the provided options
      * @param resourceName The azure resource name to format
      * @param options Options to control the formatting of the resource name
      * @returns The formatted Azure-compliant resource name
      */
-    format(resourceName: string, options?: AzureResourceNameFormatterProps): string;
+    format(resourceName: string | undefined, options?: AzureResourceNameFormatterProps): string;
 }

package/dist/src/lib/azure/common/resource-name-formatter.js

@@ -1,8 +1,12 @@
-import { Construct } from 'constructs';
-export class AzureResourceNameFormatter extends Construct {
+/**
+ * @classdesc Formats Azure resource names according to naming conventions
+ * - Applies global/resource prefixes and suffixes
+ * - Automatically appends stage to resource names
+ * - Supports per-resource customization via options
+ */
+export class AzureResourceNameFormatter {
     props;
-    constructor(parent, id, props) {
-        super(parent, id);
+    constructor(props) {
         this.props = props;
     }
     /**
@@ -17,7 +21,7 @@ export class AzureResourceNameFormatter extends Construct {
             azureResourceNameElements.push(options?.globalPrefix ? this.props.globalPrefix : undefined);
             azureResourceNameElements.push(options?.prefix ?? this.props.resourcePrefix);
         }
-        azureResourceNameElements.push(resourceName);
+        azureResourceNameElements.push(resourceName || '');
         if (!options?.exclude) {
             azureResourceNameElements.push(options?.suffix ?? this.props.resourceSuffix);
             azureResourceNameElements.push(options?.globalSuffix ? this.props.globalSuffix : undefined);

package/dist/src/lib/azure/common/stack.d.ts

@@ -1,59 +1,45 @@
-import { TerraformStack } from 'cdktf';
-import { Construct } from 'constructs';
+import { ComponentResource, ComponentResourceOptions, Config } from '@pulumi/pulumi';
 import { CommonAzureConstruct } from './construct.js';
 import { CommonAzureStackProps } from './types.js';
 /**
- * @classdesc Common stack to use as a base for all higher level constructs.
+ * @classdesc Common stack to use as a base for all higher level constructs using Pulumi
  * @example
+ * ```typescript
  * import { CommonAzureStack } from '@gradientedge/cdk-utils'
  *
  * class CustomStack extends CommonAzureStack {
- *   constructor(parent: App, name: string, props: StackProps) {
- *     super(parent, name, props)
+ *   constructor(name: string, props: CommonAzureStackProps) {
+ *     super(name, props)
  *     // provision resources
  *   }
  * }
+ * ```
  */
-export declare class CommonAzureStack extends TerraformStack {
+export declare class CommonAzureStack extends ComponentResource {
     construct: CommonAzureConstruct;
     props: CommonAzureStackProps;
-    constructor(parent: Construct, name: string, props: CommonAzureStackProps);
+    config: Config;
+    constructor(name: string, props: CommonAzureStackProps, options?: ComponentResourceOptions);
     /**
-     * @summary Method to determine the core CDK construct properties injected via context cdktf.json
+     * @summary Method to determine the core construct properties injected via context
      * @param props The stack properties
      * @returns The stack properties
      */
-    protected determineConstructProps(props: CommonAzureStackProps): {
-        domainName: any;
-        extraContexts: any;
-        features: any;
-        location: any;
-        name: any;
-        resourceGroupName: any;
-        globalPrefix: any;
-        globalSuffix: any;
-        resourceNameOptions: any;
-        resourcePrefix: any;
-        resourceSuffix: any;
-        skipStageForARecords: any;
-        stage: any;
-        subDomain: any;
-        subscriptionId: any;
-    };
+    protected determineConstructProps(props: CommonAzureStackProps): any;
     /**
-     * @summary Method to determine extra cdk contexts apart from the main cdktf.json
-     * - Sets the properties from the extra contexts into cdk node context
+     * @summary Method to determine extra contexts apart from the main context
+     * - Sets the properties from the extra contexts
      * - Primary use is to have layered config in separate files to enable easier maintenance and readability
      */
-    protected determineExtraContexts(): void;
+    protected determineExtraContexts(props: CommonAzureStackProps): Record<string, any>;
     /**
-     * @summary Method to determine extra cdk stage contexts apart from the main cdktf.json
-     * - Sets the properties from the extra stage contexts into cdk node context
+     * @summary Method to determine extra stage contexts apart from the main context
+     * - Sets the properties from the extra stage contexts
      * - Primary use is to have layered config for each environment which is injected into the context
      */
-    protected determineStageContexts(): void;
+    protected determineStageContexts(props: CommonAzureStackProps): any;
     /**
      * @summary Determine the fully qualified domain name based on domainName & subDomain
      */
-    protected fullyQualifiedDomain(): any;
+    protected fullyQualifiedDomain(): string;
 }

package/dist/src/lib/azure/common/stack.js

@@ -1,134 +1,137 @@
+import { ComponentResource, Config } from '@pulumi/pulumi';
 import appRoot from 'app-root-path';
-import { Aspects, TerraformStack } from 'cdktf';
 import fs from 'fs';
 import _ from 'lodash';
 import path from 'path';
 import { isDevStage } from '../../common/index.js';
-import { TagsAddingAspect } from './tagging.js';
+import { registerTagTransformation } from './tagging.js';
 /**
- * @classdesc Common stack to use as a base for all higher level constructs.
+ * @classdesc Common stack to use as a base for all higher level constructs using Pulumi
  * @example
+ * ```typescript
  * import { CommonAzureStack } from '@gradientedge/cdk-utils'
  *
  * class CustomStack extends CommonAzureStack {
- *   constructor(parent: App, name: string, props: StackProps) {
- *     super(parent, name, props)
+ *   constructor(name: string, props: CommonAzureStackProps) {
+ *     super(name, props)
  *     // provision resources
  *   }
  * }
+ * ```
  */
-export class CommonAzureStack extends TerraformStack {
+export class CommonAzureStack extends ComponentResource {
     construct;
     props;
-    constructor(parent, name, props) {
-        super(parent, name);
-        /* determine extra cdk contexts */
-        this.determineExtraContexts();
-        /* determine extra cdk stage contexts */
-        this.determineStageContexts();
+    config;
+    constructor(name, props, options) {
+        super(`custom:azure:Stack:${name}`, name, props, options);
+        /* initialise config */
+        this.config = new Config();
         this.props = this.determineConstructProps(props);
-        Aspects.of(this).add(new TagsAddingAspect(this.props.defaultTags || {}));
+        /* register tag transformation for automatic tag application */
+        if (this.props.defaultTags) {
+            registerTagTransformation(this.props.defaultTags);
+        }
     }
     /**
-     * @summary Method to determine the core CDK construct properties injected via context cdktf.json
+     * @summary Method to determine the core construct properties injected via context
      * @param props The stack properties
      * @returns The stack properties
      */
     determineConstructProps(props) {
+        let projectProps = props;
+        if (!projectProps) {
+            const projectPropsPath = path.join(appRoot.path, 'pulumi.json');
+            if (!fs.existsSync(projectPropsPath))
+                throw `Context properties unavailable in path:${projectPropsPath}`;
+            const projectPropsBuffer = fs.readFileSync(projectPropsPath);
+            projectProps = JSON.parse(projectPropsBuffer.toString('utf-8'));
+        }
         return {
-            domainName: this.node.tryGetContext('domainName'),
-            extraContexts: this.node.tryGetContext('extraContexts'),
-            features: this.node.tryGetContext('features'),
-            location: this.node.tryGetContext('location'),
-            name: this.node.tryGetContext('resourceGroupName'),
-            resourceGroupName: this.node.tryGetContext('resourceGroupName'),
-            globalPrefix: this.node.tryGetContext('globalPrefix'),
-            globalSuffix: this.node.tryGetContext('globalSuffix'),
-            resourceNameOptions: this.node.tryGetContext('resourceNameOptions'),
-            resourcePrefix: this.node.tryGetContext('resourcePrefix'),
-            resourceSuffix: this.node.tryGetContext('resourceSuffix'),
-            skipStageForARecords: this.node.tryGetContext('skipStageForARecords'),
-            stage: this.node.tryGetContext('stage'),
-            subDomain: this.node.tryGetContext('subDomain'),
-            subscriptionId: this.node.tryGetContext('subscriptionId'),
+            domainName: projectProps.domainName,
+            extraContexts: projectProps.extraContexts,
+            location: projectProps.location,
+            name: projectProps.resourceGroupName ?? projectProps.name,
+            resourceGroupName: projectProps.resourceGroupName,
+            globalPrefix: projectProps.globalPrefix,
+            globalSuffix: projectProps.globalSuffix,
+            resourceNameOptions: projectProps.resourceNameOptions,
+            resourcePrefix: projectProps.resourcePrefix,
+            resourceSuffix: projectProps.resourceSuffix,
+            skipStageForARecords: projectProps.skipStageForARecords,
+            stage: projectProps.stage,
+            stageContextPath: projectProps.stageContextPath,
+            subDomain: projectProps.subDomain,
+            subscriptionId: projectProps.subscriptionId,
+            tenantId: projectProps.tenantId,
+            clientId: projectProps.clientId,
+            clientSecret: projectProps.clientSecret,
+            defaultTags: projectProps.defaultTags,
+            ...this.determineExtraContexts(props),
+            ...this.determineStageContexts(props),
         };
     }
     /**
-     * @summary Method to determine extra cdk contexts apart from the main cdktf.json
-     * - Sets the properties from the extra contexts into cdk node context
+     * @summary Method to determine extra contexts apart from the main context
+     * - Sets the properties from the extra contexts
      * - Primary use is to have layered config in separate files to enable easier maintenance and readability
      */
-    determineExtraContexts() {
-        const extraContexts = this.node.tryGetContext('extraContexts');
-        const debug = this.node.tryGetContext('debug');
-        if (!extraContexts) {
-            if (debug)
-                console.debug(`No additional contexts provided. Using default context properties from cdktf.json`);
-            return;
+    determineExtraContexts(props) {
+        if (!props.extraContexts) {
+            if (props.debug)
+                console.debug(`No additional contexts provided. Using default context properties`);
+            return {};
         }
-        _.forEach(extraContexts, (context) => {
+        let extraContextProps = {};
+        _.forEach(props.extraContexts, (context) => {
             const extraContextPath = path.join(appRoot.path, context);
-            /* scenario where extra context is configured in cdk.json but absent in file system */
+            /* scenario where extra context is configured but absent in file system */
             if (!fs.existsSync(extraContextPath))
                 throw `Extra context properties unavailable in path:${extraContextPath}`;
             /* read the extra properties */
             const extraContextPropsBuffer = fs.readFileSync(extraContextPath);
-            if (debug)
+            if (props.debug)
                 console.debug(`Adding additional contexts provided in ${extraContextPath}`);
             /* parse as JSON properties */
-            const extraContextProps = JSON.parse(extraContextPropsBuffer.toString('utf-8'));
-            /* set each of the property into the cdk node context */
-            _.keys(extraContextProps).forEach((propKey) => {
-                this.node.setContext(propKey, extraContextProps[propKey]);
-            });
+            extraContextProps = {
+                ...extraContextProps,
+                ...JSON.parse(extraContextPropsBuffer.toString('utf-8')),
+            };
         });
+        return extraContextProps;
     }
     /**
-     * @summary Method to determine extra cdk stage contexts apart from the main cdktf.json
-     * - Sets the properties from the extra stage contexts into cdk node context
+     * @summary Method to determine extra stage contexts apart from the main context
+     * - Sets the properties from the extra stage contexts
      * - Primary use is to have layered config for each environment which is injected into the context
      */
-    determineStageContexts() {
-        const stage = process.env.STAGE ?? this.node.tryGetContext('stage');
-        const stageContextPath = this.node.tryGetContext('stageContextPath') || 'cdkEnv';
-        const stageContextFilePath = path.join(appRoot.path, stageContextPath, `${stage}.json`);
-        const debug = this.node.tryGetContext('debug');
-        if (isDevStage(stage)) {
-            if (debug)
+    determineStageContexts(props) {
+        const stageContextFilePath = path.join(appRoot.path, props.stageContextPath ?? 'env', `${props.stage}.json`);
+        if (isDevStage(props.stage)) {
+            if (props.debug)
                 console.debug(`Development stage. Using default stage context properties`);
         }
         /* alert default context usage when extra stage config is missing */
         if (!fs.existsSync(stageContextFilePath)) {
-            if (debug)
+            if (props.debug)
                 console.debug(`Stage specific context properties unavailable in path:${stageContextFilePath}`);
-            if (debug)
-                console.debug(`Using default stage context properties for ${stage} stage`);
-            return;
+            if (props.debug)
+                console.debug(`Using default stage context properties for ${props.stage} stage`);
+            return {};
         }
         /* read the extra properties */
         const stageContextPropsBuffer = fs.readFileSync(stageContextFilePath);
-        if (debug)
+        if (props.debug)
             console.debug(`Adding additional stage contexts provided in ${stageContextFilePath}`);
         /* parse as JSON properties */
-        const stageContextProps = JSON.parse(stageContextPropsBuffer.toString('utf-8'));
-        /* set each of the property into the cdk node context */
-        _.keys(stageContextProps).forEach((propKey) => {
-            /* handle object, array properties */
-            if (typeof stageContextProps[propKey] === 'object' && !Array.isArray(stageContextProps[propKey])) {
-                this.node.setContext(propKey, _.merge(this.node.tryGetContext(propKey), stageContextProps[propKey]));
-            }
-            else {
-                /* handle all other primitive properties */
-                this.node.setContext(propKey, stageContextProps[propKey]);
-            }
-        });
+        return JSON.parse(stageContextPropsBuffer.toString('utf-8'));
     }
     /**
      * @summary Determine the fully qualified domain name based on domainName & subDomain
      */
     fullyQualifiedDomain() {
-        const domainName = this.node.tryGetContext('domainName');
-        const subDomain = this.node.tryGetContext('subDomain');
+        const domainName = this.props.domainName;
+        const subDomain = this.props.subDomain;
         return subDomain ? `${subDomain}.${domainName}` : domainName;
     }
 }

package/dist/src/lib/azure/common/tagging.d.ts

@@ -1,8 +1,29 @@
-import { IAspect } from 'cdktf';
-import { IConstruct } from 'constructs';
-export declare class TagsAddingAspect implements IAspect {
-    private tagsToAdd;
-    private tagsToIgnore;
-    constructor(tagsToAdd: Record<string, string>, tagsToIgnore?: string[]);
-    visit(node: IConstruct): void;
-}
+/**
+ * @summary Check if a resource type is taggable
+ * @param resourceType The Pulumi resource type (e.g., 'azure-native:resources:ResourceGroup')
+ * @returns True if the resource supports tags, false otherwise
+ */
+export declare function isTaggableResource(resourceType: string): boolean;
+/**
+ * @summary Register a stack transformation to automatically apply tags to Azure resources
+ * @param defaultTags The default tags to apply to all resources
+ * @param tagsToIgnore Optional list of tag keys to ignore in lifecycle management
+ * @example
+ * ```typescript
+ * registerTagTransformation({ environment: 'production', team: 'platform' })
+ * ```
+ */
+export declare function registerTagTransformation(defaultTags: Record<string, string>, tagsToIgnore?: string[]): void;
+/**
+ * @summary Helper function to apply tags to a specific resource's properties
+ * @param props The resource properties
+ * @param defaultTags The default tags to merge with existing tags
+ * @returns The properties with merged tags
+ * @example
+ * ```typescript
+ * const resourceGroupProps = applyTags(props, { environment: 'dev' })
+ * ```
+ */
+export declare function applyTags<T extends {
+    tags?: Record<string, string>;
+}>(props: T, defaultTags: Record<string, string>): T;