terruvim-core-test 0.0.1

package/dist/src/core/dynamicResourceManager.js

@@ -0,0 +1,709 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DynamicResourceManager = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const pulumi = __importStar(require("@pulumi/pulumi"));
+const aws = __importStar(require("@pulumi/aws"));
+const resourceMap_1 = require("./resourceMap");
+const budgetFactory_1 = require("../factories/budgetFactory");
+const cloudTrailFactory_1 = require("../factories/cloudTrailFactory");
+const costAndUsageReportFactory_1 = require("../factories/costAndUsageReportFactory");
+const macieFactory_1 = require("../factories/macieFactory");
+const organizationFactory_1 = require("../factories/organizationFactory");
+const savingsPlanFactory_1 = require("../factories/savingsPlanFactory");
+const securityHubFactory_1 = require("../factories/securityHubFactory");
+const inspectorFactory_1 = require("../factories/inspectorFactory");
+const guardDutyFactory_1 = require("../factories/guardDutyFactory");
+const ssoFactory_1 = require("../factories/ssoFactory");
+const ssoPermissionSetFactory_1 = require("../factories/ssoPermissionSetFactory");
+const ssoUserFactory_1 = require("../factories/ssoUserFactory");
+const ssoGroupFactory_1 = require("../factories/ssoGroupFactory");
+const rdsFactory_1 = require("../factories/rdsFactory");
+const auroraFactory_1 = require("../factories/auroraFactory");
+const s3Factory_1 = require("../factories/s3Factory");
+const snsFactory_1 = require("../factories/snsFactory");
+const sqsFactory_1 = require("../factories/sqsFactory");
+const stepFunctionsFactory_1 = require("../factories/stepFunctionsFactory");
+const eventBridgeFactory_1 = require("../factories/eventBridgeFactory");
+const eventBridgeRuleFactory_1 = require("../factories/eventBridgeRuleFactory");
+const sesFactory_1 = require("../factories/sesFactory");
+const sesDomainDkimFactory_1 = require("../factories/sesDomainDkimFactory");
+const sesIdentitiesFactory_1 = require("../factories/sesIdentitiesFactory");
+const hostedZoneFactory_1 = require("../factories/hostedZoneFactory");
+const recordFactory_1 = require("../factories/recordFactory");
+const acmFactory_1 = require("../factories/acmFactory");
+const securityGroupRuleFactory_1 = require("../factories/securityGroupRuleFactory");
+const securityGroupFactory_1 = require("../factories/securityGroupFactory");
+const iamRoleFactory_1 = require("../factories/iamRoleFactory");
+const kmsKeyFactory_1 = require("../factories/kmsKeyFactory");
+const secretsManagerFactory_1 = require("../factories/secretsManagerFactory");
+const ec2Factory_1 = require("../factories/ec2Factory");
+const lambdaFactory_1 = require("../factories/lambdaFactory");
+const lambdaPermissionFactory_1 = require("../factories/lambdaPermissionFactory");
+const vpcEndpointFactory_1 = require("../factories/vpcEndpointFactory");
+const smtpUserFactory_1 = require("../factories/smtpUserFactory");
+const codeStarConnectionFactory_1 = require("../factories/codeStarConnectionFactory");
+const cloudwatchAlarmsFactory_1 = require("../factories/cloudwatchAlarmsFactory");
+const dashboardFactory_1 = require("../factories/dashboardFactory");
+const cloudWatchCompositeAlarmFactory_1 = require("../factories/cloudWatchCompositeAlarmFactory");
+const cloudWatchInsightsQueryFactory_1 = require("../factories/cloudWatchInsightsQueryFactory");
+const cloudWatchLogGroupFactory_1 = require("../factories/cloudWatchLogGroupFactory");
+const logDataProtectionPolicyFactory_1 = require("../factories/logDataProtectionPolicyFactory");
+const ssmParameterFactory_1 = require("../factories/ssmParameterFactory");
+const bastionFactory_1 = require("../factories/bastionFactory");
+const ecsCodePipelineFactory_1 = require("../factories/ecsCodePipelineFactory");
+const cloudfrontCodePipelineFactory_1 = require("../factories/cloudfrontCodePipelineFactory");
+const ecsServiceFactory_1 = require("../factories/ecsServiceFactory");
+const ecsClusterFactory_1 = require("../factories/ecsClusterFactory");
+const s3StaticHostingFactory_1 = require("../factories/s3StaticHostingFactory");
+const albFactory_1 = require("../factories/albFactory");
+const networkingFactory_1 = require("../factories/networkingFactory");
+const enhancedEcsCodePipelineFactory_1 = require("../factories/enhancedEcsCodePipelineFactory");
+const enhancedCloudFrontCodePipelineFactory_1 = require("../factories/enhancedCloudFrontCodePipelineFactory");
+const simpleNotificationFactory_1 = require("../factories/simpleNotificationFactory");
+const codePipelineNotificationRulesFactory_1 = require("../factories/codePipelineNotificationRulesFactory");
+const bedrockFactory_1 = require("../factories/bedrockFactory");
+const opensearchCollectionFactory_1 = require("../factories/opensearchCollectionFactory");
+const lambdaFactory_2 = require("../factories/lambdaFactory");
+const eventBridgeBusFactory_1 = require("../factories/eventBridgeBusFactory");
+const globalResourceRegistry = new Set();
+function loadProviders(config) {
+    const providers = {};
+    let providerConfigs = {};
+    if (config.providers && Object.keys(config.providers).length > 0) {
+        providerConfigs = config.providers;
+    }
+    else if (config.meta && config.meta.providers) {
+        providerConfigs = config.meta.providers;
+    }
+    for (const [name, provCfg] of Object.entries(providerConfigs)) {
+        if (name === "default")
+            continue;
+        providers[name] = new aws.Provider(name, {
+            region: provCfg.region,
+            profile: provCfg.profile,
+            assumeRole: provCfg.assumeRole,
+        });
+    }
+    return providers;
+}
+class DynamicResourceManager {
+    config;
+    deployedResources = {};
+    resourceOutputs = {};
+    factories = new Map();
+    providers = {};
+    constructor(configPath) {
+        const resolvedPath = path.resolve(configPath);
+        this.config = JSON.parse(fs.readFileSync(resolvedPath, "utf-8"));
+        this.factories.set("l2_organizationFactory", new organizationFactory_1.OrganizationFactory());
+        this.factories.set("l2_budgetFactory", new budgetFactory_1.BudgetFactory());
+        this.factories.set("l2_cloudTrailFactory", new cloudTrailFactory_1.CloudTrailFactory());
+        this.factories.set("l2_curFactory", new costAndUsageReportFactory_1.CostAndUsageReportFactory());
+        this.factories.set("l2_guardDutyFactory", new guardDutyFactory_1.GuardDutyFactory());
+        this.factories.set("l2_macieFactory", new macieFactory_1.MacieFactory());
+        this.factories.set("l2_savingsPlanFactory", new savingsPlanFactory_1.SavingsPlanFactory());
+        this.factories.set("l2_billingFactory", new budgetFactory_1.BudgetFactory());
+        this.factories.set("l2_securityHubFactory", new securityHubFactory_1.SecurityHubFactory());
+        this.factories.set("l2_inspectorFactory", new inspectorFactory_1.InspectorFactory());
+        this.factories.set("l2_ssoFactory", new ssoFactory_1.SSOFactory());
+        this.factories.set("l2_ssoPermissionSetFactory", new ssoPermissionSetFactory_1.SSOPermissionSetFactory());
+        this.factories.set("l2_ssoUserFactory", new ssoUserFactory_1.SsoUserFactory());
+        this.factories.set("l2_ssoGroupFactory", new ssoGroupFactory_1.SsoGroupFactory());
+        this.factories.set("l3_rdsFactory", new rdsFactory_1.RdsFactory());
+        this.factories.set("l3_auroraFactory", new auroraFactory_1.AuroraFactory());
+        this.factories.set("l3_snsFactory", new snsFactory_1.SnsFactory());
+        this.factories.set("l3_sqsFactory", new sqsFactory_1.SqsFactory());
+        this.factories.set("l3_eventBridgeFactory", new eventBridgeFactory_1.EventBridgeFactory());
+        this.factories.set("l3_eventBridgeRuleFactory", new eventBridgeRuleFactory_1.EventBridgeRuleFactory());
+        this.factories.set("l3_eventBridgeCustomBusFactory", new eventBridgeBusFactory_1.EventBridgeBusFactory());
+        this.factories.set("l3_stepFunctionsFactory", new stepFunctionsFactory_1.StepFunctionsFactory());
+        this.factories.set("l3_smtpUserFactory", new smtpUserFactory_1.SmtpUserFactory());
+        this.factories.set("l3_sesFactory", new sesFactory_1.SesFactory());
+        this.factories.set("l3_sesDomainDkimFactory", new sesDomainDkimFactory_1.SesDomainDkimFactory());
+        this.factories.set("l3_sesIdentitiesFactory", new sesIdentitiesFactory_1.SesIdentitiesFactory());
+        this.factories.set("l3_s3Factory", new s3Factory_1.S3Factory());
+        this.factories.set("l3_hostedZonesFactory", new hostedZoneFactory_1.HostedZoneFactory());
+        this.factories.set("l3_recordsFactory", new recordFactory_1.RecordFactory());
+        this.factories.set("l3_acmFactory", new acmFactory_1.AcmFactory());
+        this.factories.set("l3_iamRolesFactory", new iamRoleFactory_1.IamRoleFactory());
+        this.factories.set("l3_kmsKeysFactory", new kmsKeyFactory_1.KmsKeyFactory());
+        this.factories.set("l3_secretsManagerFactory", new secretsManagerFactory_1.SecretsManagerFactory());
+        this.factories.set("l3_ec2Factory", new ec2Factory_1.Ec2Factory());
+        this.factories.set("l3_lambdaFactory", new lambdaFactory_1.LambdaFactory());
+        this.factories.set("l3_lambdaPermissionFactory", new lambdaPermissionFactory_1.LambdaPermissionFactory());
+        this.factories.set("l3_vpcEndpointFactory", new vpcEndpointFactory_1.VpcEndpointFactory());
+        this.factories.set("l3_securityGroupsFactory", new securityGroupFactory_1.SecurityGroupFactory());
+        this.factories.set("l3_securityGroupRulesFactory", new securityGroupRuleFactory_1.SecurityGroupRuleFactory());
+        this.factories.set("l3_codeStarConnectionFactory", new codeStarConnectionFactory_1.CodeStarConnectionFactory());
+        this.factories.set("l3_cloudWatchAlarmsFactory", new cloudwatchAlarmsFactory_1.CloudWatchAlarmsFactory());
+        this.factories.set("l3_cloudWatchDashboardFactory", new dashboardFactory_1.DashboardFactory());
+        this.factories.set("l3_cloudWatchCompositeAlarmFactory", new cloudWatchCompositeAlarmFactory_1.CloudWatchCompositeAlarmFactory());
+        this.factories.set("l3_cloudWatchInsightsQueryFactory", new cloudWatchInsightsQueryFactory_1.CloudWatchInsightsQueryFactory());
+        this.factories.set("l3_cloudWatchLogGroupFactory", new cloudWatchLogGroupFactory_1.CloudWatchLogGroupFactory());
+        this.factories.set("l3_logDataProtectionPolicyFactory", new logDataProtectionPolicyFactory_1.LogDataProtectionPolicyFactory());
+        this.factories.set("l3_ssmParameterFactory", new ssmParameterFactory_1.SSMParameterFactory());
+        this.factories.set("l4_basicNetworkingFactory", new networkingFactory_1.AdvancedNetworkingFactory());
+        this.factories.set("l4_albFactory", new albFactory_1.AlbFactory());
+        this.factories.set("l4_bastionFactory", new bastionFactory_1.BastionFactory());
+        this.factories.set("l4_ecsClusterFactory", new ecsClusterFactory_1.ClusterFactory());
+        this.factories.set("l4_ecsServiceFactory", new ecsServiceFactory_1.ServiceFactory());
+        this.factories.set("l4_ecsCodePipelinesFactory", new ecsCodePipelineFactory_1.ECSCodePipelineFactory());
+        this.factories.set("l4_cloudfrontCodePipelineFactory", new cloudfrontCodePipelineFactory_1.CloudFrontCodePipelineFactory());
+        this.factories.set("l4_s3StaticHostingFactory", new s3StaticHostingFactory_1.S3StaticHostingFactory());
+        this.factories.set("l4_enhancedEcsCodePipelineFactory", new enhancedEcsCodePipelineFactory_1.EnhancedEcsCodePipelineFactory());
+        this.factories.set("l4_enhancedCloudFrontCodePipelineFactory", new enhancedCloudFrontCodePipelineFactory_1.EnhancedCloudFrontCodePipelineFactory());
+        this.factories.set("l4_simpleNotificationFactory", new simpleNotificationFactory_1.SimpleNotificationFactory());
+        this.factories.set("l4_codePipelineNotificationRulesFactory", new codePipelineNotificationRulesFactory_1.CodePipelineNotificationRulesFactory());
+        this.factories.set("l4_bedrockFactory", new bedrockFactory_1.BedrockFactory());
+        this.factories.set("l4_opensearchCollectionFactory", new opensearchCollectionFactory_1.OpenSearchCollectionFactory());
+        this.factories.set("l4_lambdaFactory", new lambdaFactory_2.LambdaFactory());
+        this.providers = loadProviders(this.config);
+        Object.entries(this.providers).forEach(([key, provider]) => { });
+    }
+    resolveInputs(inputs) {
+        const resolved = {};
+        for (const [key, value] of Object.entries(inputs || {})) {
+            let resolvedValue = value;
+            if (typeof value === "string" && value.startsWith("${output:")) {
+                const match = value.match(/^[\$]{output:([^.]+)\.([\w$]+)(\[(\d+)\])?}$/);
+                if (match) {
+                    const [, resourceId, outputKey, , indexStr] = match;
+                    let outputVal = this.resourceOutputs[resourceId]?.[outputKey];
+                    if (outputVal === undefined) {
+                        throw new Error(`Output value for ${resourceId}.${outputKey} is not available`);
+                    }
+                    if (indexStr !== undefined && Array.isArray(outputVal)) {
+                        resolvedValue = outputVal[parseInt(indexStr, 10)];
+                    }
+                    else {
+                        resolvedValue = outputVal;
+                    }
+                }
+            }
+            const logValue = typeof resolvedValue === 'object' && resolvedValue !== null && typeof resolvedValue.apply === 'function'
+                ? '[Pulumi Output]'
+                : resolvedValue;
+            console.log(`[resolveInputs] key: ${key}, raw:`, value, ', resolved:', logValue);
+            resolved[key] = resolvedValue;
+        }
+        return resolved;
+    }
+    async resolveOutputsDeep(obj) {
+        if (Array.isArray(obj)) {
+            const resolvedArray = await Promise.all(obj.map(item => this.resolveOutputsDeep(item)));
+            return resolvedArray;
+        }
+        if (obj && typeof obj === "object") {
+            const resolved = {};
+            for (const [key, value] of Object.entries(obj)) {
+                resolved[key] = await this.resolveOutputsDeep(value);
+            }
+            return resolved;
+        }
+        if (typeof obj === "string") {
+            let resolvedString = obj;
+            let hasChanges = true;
+            let maxIterations = 10;
+            let iteration = 0;
+            while (hasChanges && iteration < maxIterations) {
+                const originalString = resolvedString;
+                if (this.isMetaPattern(resolvedString)) {
+                    resolvedString = this.resolveMetaPattern(resolvedString);
+                }
+                if (this.isIdPattern(resolvedString)) {
+                    resolvedString = this.resolveIdPattern(resolvedString);
+                }
+                if (this.isOutputPattern(resolvedString)) {
+                    const outputResolved = this.resolveOutputPattern(resolvedString);
+                    if (typeof outputResolved === "string") {
+                        resolvedString = outputResolved;
+                    }
+                    else {
+                        resolvedString = outputResolved;
+                    }
+                }
+                if (typeof resolvedString === "object" && resolvedString !== null && typeof resolvedString.apply === "function") {
+                    return resolvedString.apply(async (value) => {
+                        let finalString = value;
+                        if (this.isSecretPattern(finalString)) {
+                            finalString = await this.resolveSecretPatternAsync(finalString);
+                        }
+                        return finalString;
+                    });
+                }
+                if (this.isSecretPattern(resolvedString)) {
+                    resolvedString = await this.resolveSecretPatternAsync(resolvedString);
+                }
+                hasChanges = (originalString !== resolvedString);
+                iteration++;
+            }
+            if (iteration >= maxIterations) {
+                console.warn(`Maximum iterations reached while resolving patterns in string: ${obj}`);
+            }
+            return resolvedString;
+        }
+        return obj;
+    }
+    isOutputPattern(str) {
+        return /\$\{output:([^.}]+)\.([\w$]+)((?:\[\d+\])?(?:\.[\w$]+)*)\}/.test(str);
+    }
+    resolveOutputPattern(str) {
+        const fullMatch = str.match(/^\$\{output:([^.}]+)\.([\w$]+)((?:\[\d+\])?(?:\.[\w$]+)*)}$/);
+        if (fullMatch) {
+            const [, resourceId, outputKey, rest] = fullMatch;
+            let outputVal;
+            try {
+                outputVal = (0, resourceMap_1.getResourceOutput)(resourceId, outputKey);
+            }
+            catch (e) {
+                return str;
+            }
+            let chain = rest || "";
+            const chainRegex = /(\[\d+\])|\.([\w$]+)/g;
+            let match;
+            let accessors = [];
+            while ((match = chainRegex.exec(chain)) !== null) {
+                if (match[1]) {
+                    accessors.push(Number(match[1].slice(1, -1)));
+                }
+                else if (match[2]) {
+                    accessors.push(match[2]);
+                }
+            }
+            function resolveChain(val, accs) {
+                if (accs.length === 0)
+                    return val;
+                const [head, ...tail] = accs;
+                if (val == null)
+                    return val;
+                if (typeof val === "object" && val !== null && typeof val.apply === "function") {
+                    return val.apply((v) => resolveChain(v, accs));
+                }
+                if (typeof head === "number" && Array.isArray(val)) {
+                    return resolveChain(val[head], tail);
+                }
+                if (typeof head === "string" && typeof val === "object" && val !== null) {
+                    return resolveChain(val[head], tail);
+                }
+                return undefined;
+            }
+            return resolveChain(outputVal, accessors);
+        }
+        const regex = /\$\{output:([^.}]+)\.([\w$]+)((?:\[\d+\])?(?:\.[\w$]+)*)\}/g;
+        const matches = [...str.matchAll(regex)];
+        if (matches.length === 0)
+            return str;
+        const values = matches.map(match => {
+            const [, resourceId, outputKey, rest] = match;
+            let outputVal;
+            try {
+                outputVal = (0, resourceMap_1.getResourceOutput)(resourceId, outputKey);
+            }
+            catch (e) {
+                return match[0];
+            }
+            let chain = rest || "";
+            const chainRegex = /(\[\d+\])|\.([\w$]+)/g;
+            let m;
+            let accessors = [];
+            while ((m = chainRegex.exec(chain)) !== null) {
+                if (m[1]) {
+                    accessors.push(Number(m[1].slice(1, -1)));
+                }
+                else if (m[2]) {
+                    accessors.push(m[2]);
+                }
+            }
+            function resolveChain(val, accs) {
+                if (accs.length === 0)
+                    return val;
+                const [head, ...tail] = accs;
+                if (val == null)
+                    return val;
+                if (typeof val === "object" && val !== null && typeof val.apply === "function") {
+                    return val.apply((v) => resolveChain(v, accs));
+                }
+                if (typeof head === "number" && Array.isArray(val)) {
+                    return resolveChain(val[head], tail);
+                }
+                if (typeof head === "string" && typeof val === "object" && val !== null) {
+                    return resolveChain(val[head], tail);
+                }
+                return undefined;
+            }
+            return resolveChain(outputVal, accessors);
+        });
+        if (values.some(v => typeof v === "object" && v !== null && typeof v.apply === "function")) {
+            return pulumi.all(values).apply((resolvedValues) => {
+                let result = str;
+                matches.forEach((match, i) => {
+                    const valueStr = typeof resolvedValues[i] === 'object' && resolvedValues[i] !== null
+                        ? JSON.stringify(resolvedValues[i])
+                        : String(resolvedValues[i]);
+                    result = result.replace(match[0], valueStr);
+                });
+                return result;
+            });
+        }
+        else {
+            let result = str;
+            matches.forEach((match, i) => {
+                const valueStr = typeof values[i] === 'object' && values[i] !== null
+                    ? JSON.stringify(values[i])
+                    : String(values[i]);
+                result = result.replace(match[0], valueStr);
+            });
+            return result;
+        }
+    }
+    isMetaPattern(str) {
+        return /\$\{meta\.[^}]+\}/.test(str);
+    }
+    resolveMetaPattern(str) {
+        if (this.config && this.config.meta) {
+            const fullMatch = str.match(/^\$\{meta\.([^}]+)\}$/);
+            if (fullMatch) {
+                const keyPath = fullMatch[1];
+                const parts = keyPath.split(/\.|\/+?/);
+                let val = this.config.meta;
+                for (const part of parts) {
+                    if (val == null)
+                        break;
+                    val = val[part];
+                }
+                return typeof val !== "undefined" ? val : "";
+            }
+            return str.replace(/\$\{meta\.([^}]+)\}/g, (_, keyPath) => {
+                const parts = keyPath.split(/\.|\/+?/);
+                let val = this.config.meta;
+                for (const part of parts) {
+                    if (val == null)
+                        break;
+                    val = val[part];
+                }
+                return typeof val !== "undefined" ? String(val) : "";
+            });
+        }
+        return str;
+    }
+    isIdPattern(str) {
+        return /\$\{id\}/.test(str);
+    }
+    resolveIdPattern(str) {
+        let idVal = "";
+        if (this.config && typeof this.config.id === "string") {
+            idVal = this.config.id;
+        }
+        return str.replace(/\$\{id\}/g, idVal);
+    }
+    isSecretPattern(str) {
+        return /\$\{secret:[^:}]+:[^}]+\}/.test(str);
+    }
+    resolveSecretPattern(str) {
+        const match = str.match(/\$\{secret:([^:}]+):([^}]+)\}(.*)$/);
+        if (match) {
+            const [_, secretId, key, suffix] = match;
+            const secretResource = this.deployedResources[secretId] || this.resourceOutputs[secretId];
+            if (secretResource && secretResource[key]) {
+                return secretResource[key] + (suffix || '');
+            }
+            return str;
+        }
+        return str;
+    }
+    async resolveSecretPatternAsync(str, region) {
+        const secretPattern = /\$\{secret:([^:}]+):([^}]+)\}/g;
+        const matches = Array.from(str.matchAll(secretPattern));
+        if (matches.length === 0) {
+            return str;
+        }
+        let result = str;
+        for (const match of matches) {
+            const [fullMatch, secretId, key] = match;
+            let resolvedValue = '';
+            const secretResource = this.deployedResources[secretId] || this.resourceOutputs[secretId];
+            if (secretResource && secretResource[key]) {
+                console.log(`Resolved secret key ${key} from local resources for secret ${secretId}`);
+                resolvedValue = secretResource[key];
+            }
+            else {
+                try {
+                    const awsRegion = region || this.config?.providers?.default?.region || 'us-east-1';
+                    const secretVersion = await aws.secretsmanager.getSecretVersion({
+                        secretId: secretId,
+                    });
+                    if (secretVersion && secretVersion.secretString) {
+                        let parsed;
+                        try {
+                            parsed = JSON.parse(secretVersion.secretString);
+                        }
+                        catch (e) {
+                            parsed = { [key]: secretVersion.secretString };
+                        }
+                        if (key in parsed) {
+                            resolvedValue = parsed[key];
+                        }
+                        else {
+                            console.warn(`Secret key ${key} not found in AWS Secrets Manager secret ${secretId}. Available keys: ${Object.keys(parsed).join(', ')}`);
+                            resolvedValue = fullMatch;
+                        }
+                    }
+                    else {
+                        resolvedValue = fullMatch;
+                    }
+                }
+                catch (error) {
+                    console.warn(`Failed to fetch secret ${secretId} from AWS Secrets Manager:`, error.message);
+                    if (error.message && error.message.includes('ResourceNotFoundException')) {
+                        console.warn(`Secret ${secretId} does not exist in AWS Secrets Manager`);
+                    }
+                    else if (error.message && (error.message.includes('UnauthorizedOperation') || error.message.includes('AccessDenied'))) {
+                        console.warn(`Access denied when trying to fetch secret ${secretId}. Check IAM permissions.`);
+                    }
+                    resolvedValue = fullMatch;
+                }
+            }
+            result = result.replace(fullMatch, resolvedValue);
+        }
+        return result;
+    }
+    async deployResource(category, resourceKey, resourceConfig) {
+        const factory = this.factories.get(resourceKey);
+        if (!factory)
+            throw new Error(`No factory registered for resource type: ${resourceKey}`);
+        let resolvedConfig;
+        if (resourceConfig && typeof resourceConfig === 'object') {
+            resolvedConfig = { ...resourceConfig };
+            if (resourceConfig.configuration) {
+                resolvedConfig.configuration = await this.resolveOutputsDeep(resourceConfig.configuration);
+            }
+            if (resourceConfig.inputs) {
+                resolvedConfig.inputs = await this.resolveOutputsDeep(resourceConfig.inputs);
+                if (typeof resolvedConfig.inputs.providers === "string") {
+                    const provName = resolvedConfig.inputs.providers;
+                    if (this.providers[provName]) {
+                        resolvedConfig.inputs.providers = { [provName]: this.providers[provName] };
+                    }
+                    else {
+                        console.warn(`[DynamicResourceManager] Provider '${provName}' not found in registry, cannot inject into inputs.providers`);
+                    }
+                }
+            }
+        }
+        else {
+            resolvedConfig = await this.resolveOutputsDeep(resourceConfig);
+        }
+        resolvedConfig.meta = this.config.meta;
+        if (resourceKey === "l3_auroraFactory" && resolvedConfig.configuration && resolvedConfig.configuration.finalSnapshotIdentifier) { }
+        let provider = undefined;
+        const providerName = resourceConfig.provider || "default";
+        if (providerName !== "default") {
+            provider = this.providers[providerName];
+            if (!provider)
+                throw new Error(`Provider '${providerName}' is not defined in config.providers`);
+        }
+        factory.validateConfig(resolvedConfig);
+        if (factory.constructor.supportsProviderRegistry === true) {
+            const resource = await factory.createResource(resolvedConfig, provider, this.providers);
+            const outputsConfig = resourceConfig.outputs || {};
+            const allOutputs = factory.getOutputs(resource);
+            const filteredOutputs = {};
+            for (const key of Object.keys(outputsConfig)) {
+                filteredOutputs[key] = allOutputs[key];
+            }
+            this.resourceOutputs[resourceConfig.id] = filteredOutputs;
+            return filteredOutputs;
+        }
+        else {
+            const resource = provider
+                ? await factory.createResource(resolvedConfig, provider)
+                : await factory.createResource(resolvedConfig);
+            const outputsConfig = resourceConfig.outputs || {};
+            const allOutputs = factory.getOutputs(resource);
+            const filteredOutputs = {};
+            for (const key of Object.keys(outputsConfig)) {
+                filteredOutputs[key] = allOutputs[key];
+            }
+            this.resourceOutputs[resourceConfig.id] = filteredOutputs;
+            return filteredOutputs;
+        }
+    }
+    flattenResources() {
+        const flat = [];
+        const resourceTypes = Array.from(this.factories.keys());
+        function recurse(obj, category) {
+            if (Array.isArray(obj)) {
+                for (const item of obj) {
+                    recurse(item, category);
+                }
+            }
+            else if (obj && typeof obj === "object") {
+                for (const [key, value] of Object.entries(obj)) {
+                    if (resourceTypes.includes(key) && Array.isArray(value)) {
+                        for (const resourceConfig of value) {
+                            flat.push({ category, resourceKey: key, config: resourceConfig });
+                        }
+                    }
+                    else if (typeof value === "object" && value !== null) {
+                        recurse(value, category);
+                    }
+                }
+            }
+        }
+        for (const [category, resources] of Object.entries(this.config)) {
+            if (category === "meta")
+                continue;
+            recurse(resources, category);
+        }
+        return flat;
+    }
+    topoSortResources(resources) {
+        const sorted = [];
+        const visited = new Set();
+        const temp = new Set();
+        const byId = Object.fromEntries(resources.map(r => [r.config.id, r]));
+        function visit(res) {
+            if (visited.has(res.config.id))
+                return;
+            if (temp.has(res.config.id))
+                throw new Error(`Cyclic dependency detected for resource ${res.config.id}`);
+            temp.add(res.config.id);
+            const deps = res.config.dependsOn || [];
+            for (const depId of deps) {
+                if (byId[depId])
+                    visit(byId[depId]);
+            }
+            temp.delete(res.config.id);
+            visited.add(res.config.id);
+            sorted.push(res);
+        }
+        for (const res of resources) {
+            visit(res);
+        }
+        return sorted;
+    }
+    async deployResources() {
+        const flatResources = this.flattenResources();
+        const sortedResources = this.topoSortResources(flatResources);
+        for (const { category, resourceKey, config } of sortedResources) {
+            let resolvedEnabled = config.enabled;
+            if (typeof config.enabled === "string" && this.isMetaPattern(config.enabled)) {
+                resolvedEnabled = this.resolveMetaPattern(config.enabled);
+            }
+            config.enabled = resolvedEnabled;
+            if (!config.enabled) {
+                continue;
+            }
+            if (this.deployedResources[config.id] || globalResourceRegistry.has(config.id)) {
+                console.warn(`Resource with ID ${config.id} is already deployed. Skipping.`);
+                continue;
+            }
+            if (config.dependsOn) {
+                let skip = false;
+                for (const dependency of config.dependsOn) {
+                    if (!this.deployedResources[dependency]) {
+                        console.warn(`Dependency ${dependency} for resource ${config.id} is not ready. Skipping.`);
+                        skip = true;
+                        break;
+                    }
+                }
+                if (skip)
+                    continue;
+            }
+            try {
+                const resource = await this.deployResource(category, resourceKey, config);
+                this.deployedResources[config.id] = resource;
+                globalResourceRegistry.add(config.id);
+                const outputs = Object.keys(config.outputs || {});
+                if (outputs.length > 0) {
+                    (0, resourceMap_1.registerResource)(config.id, resource, outputs);
+                }
+            }
+            catch (error) {
+                console.error(`Failed to deploy resource ${config.id}:`, error);
+            }
+        }
+    }
+    registerResources() {
+        Object.entries(this.deployedResources).forEach(([resourceId, resource]) => {
+            const resourceConfig = this.findResourceConfigById(resourceId);
+            if (!resourceConfig) {
+                console.error(`Error: Resource configuration for ${resourceId} not found. Skipping registration.`);
+                return;
+            }
+            const outputs = Object.keys(resourceConfig.outputs || {});
+            if (outputs.length === 0) {
+                console.warn(`Warning: No outputs defined for resource ${resourceId}.`);
+            }
+            if (!resource) {
+                console.error(`Error: Resource ${resourceId} is undefined and cannot be registered.`);
+                return;
+            }
+            (0, resourceMap_1.registerResource)(resourceId, resource, outputs);
+        });
+    }
+    getConfig() {
+        return this.config;
+    }
+    getAllDeployedResources() {
+        return this.deployedResources;
+    }
+    findResourceConfigById(resourceId) {
+        function search(obj) {
+            if (Array.isArray(obj)) {
+                for (const item of obj) {
+                    const found = search(item);
+                    if (found)
+                        return found;
+                }
+            }
+            else if (obj && typeof obj === "object") {
+                if (obj.id === resourceId)
+                    return obj;
+                for (const value of Object.values(obj)) {
+                    const found = search(value);
+                    if (found)
+                        return found;
+                }
+            }
+            return undefined;
+        }
+        return search(this.config);
+    }
+}
+exports.DynamicResourceManager = DynamicResourceManager;