@geek-fun/serverlessinsight 0.4.0 → 0.5.0

package/dist/src/stack/aliyunStack/databaseExecutor.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeDatabasePlan = void 0;
+const databaseResource_1 = require("./databaseResource");
+const common_1 = require("../../common");
+const stateManager_1 = require("../../common/stateManager");
+const lang_1 = require("../../lang");
+const getResourceTypeName = (resourceType) => resourceType === 'ALIYUN_ES_SERVERLESS' ? 'Elasticsearch Serverless' : 'RDS Serverless';
+const executeCreateAction = async (context, database, resourceType, currentState) => {
+    const resourceTypeName = getResourceTypeName(resourceType);
+    common_1.logger.info(`Creating ${resourceTypeName} database: ${database.name}`);
+    const newState = await (0, databaseResource_1.createDatabaseResource)(context, database, currentState);
+    common_1.logger.info(`Successfully created ${resourceTypeName} database: ${database.name}`);
+    return newState;
+};
+const executeUpdateAction = async (context, database, instanceId, resourceType, currentState) => {
+    const resourceTypeName = getResourceTypeName(resourceType);
+    common_1.logger.info(`Updating ${resourceTypeName} database: ${database.name}`);
+    const newState = await (0, databaseResource_1.updateDatabaseResource)(context, database, instanceId, resourceType, currentState);
+    common_1.logger.info(`Successfully updated ${resourceTypeName} database: ${database.name}`);
+    return newState;
+};
+const executeDeleteAction = async (context, instanceId, resourceType, logicalId, currentState) => {
+    const resourceTypeName = getResourceTypeName(resourceType);
+    common_1.logger.info(`Deleting ${resourceTypeName} database: ${instanceId}`);
+    const newState = await (0, databaseResource_1.deleteDatabaseResource)(context, instanceId, resourceType, logicalId, currentState);
+    common_1.logger.info(`Successfully deleted ${resourceTypeName} database: ${instanceId}`);
+    return newState;
+};
+const executeSingleItem = async (context, item, databasesMap, currentState) => {
+    if (item.resourceType !== 'ALIYUN_RDS_SERVERLESS' &&
+        item.resourceType !== 'ALIYUN_ES_SERVERLESS') {
+        return null;
+    }
+    switch (item.action) {
+        case 'noop':
+            common_1.logger.info(`No changes for ${item.logicalId}`);
+            return null;
+        case 'create': {
+            const database = databasesMap.get(item.logicalId);
+            if (!database) {
+                throw new Error(`Database not found for logical ID: ${item.logicalId}`);
+            }
+            return executeCreateAction(context, database, item.resourceType, currentState);
+        }
+        case 'update': {
+            const database = databasesMap.get(item.logicalId);
+            if (!database) {
+                throw new Error(`Database not found for logical ID: ${item.logicalId}`);
+            }
+            const state = (0, stateManager_1.getResource)(currentState, item.logicalId);
+            if (!state) {
+                throw new Error(`State not found for ${item.logicalId}`);
+            }
+            const instanceId = state.metadata?.instanceId || state.instances?.[0]?.id;
+            const resourceType = state.metadata?.resourceType || item.resourceType;
+            if (!instanceId) {
+                throw new Error(`Instance ID not found in state for ${item.logicalId}`);
+            }
+            return executeUpdateAction(context, database, instanceId, resourceType, currentState);
+        }
+        case 'delete': {
+            const state = (0, stateManager_1.getResource)(currentState, item.logicalId);
+            if (!state) {
+                common_1.logger.warn(`State not found for ${item.logicalId}, skipping deletion`);
+                return null;
+            }
+            const instanceId = state.metadata?.instanceId || state.instances?.[0]?.id;
+            const resourceType = state.metadata?.resourceType || item.resourceType;
+            if (!instanceId) {
+                throw new Error(`Instance ID not found in state for ${item.logicalId}`);
+            }
+            return executeDeleteAction(context, instanceId, resourceType, item.logicalId, currentState);
+        }
+        default:
+            common_1.logger.warn(`Unknown action: ${item.action} for ${item.logicalId}`);
+            return null;
+    }
+};
+const executeDatabasePlan = async (context, plan, databases, initialState, onStateChange) => {
+    const databasesMap = new Map(databases?.map((database) => [`databases.${database.key}`, database]) ?? []);
+    const successfulItems = [];
+    let currentState = initialState;
+    for (const item of plan.items) {
+        try {
+            const newState = await executeSingleItem(context, item, databasesMap, currentState);
+            if (newState !== null) {
+                currentState = newState;
+                successfulItems.push(item);
+                if (onStateChange) {
+                    onStateChange(currentState);
+                    common_1.logger.debug(lang_1.lang.__('STATE_PERSISTED_AFTER_OPERATION', {
+                        action: item.action,
+                        resourceId: item.logicalId,
+                    }));
+                }
+            }
+        }
+        catch (error) {
+            return {
+                state: currentState,
+                partialFailure: {
+                    failedItem: item,
+                    error: error instanceof Error ? error : new Error(String(error)),
+                    successfulItems,
+                },
+            };
+        }
+    }
+    return { state: currentState };
+};
+exports.executeDatabasePlan = executeDatabasePlan;

package/dist/src/stack/aliyunStack/databasePlanner.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateDatabasePlan = void 0;
+const aliyunClient_1 = require("../../common/aliyunClient");
+const rdsTypes_1 = require("./rdsTypes");
+const esServerlessTypes_1 = require("./esServerlessTypes");
+const stateManager_1 = require("../../common/stateManager");
+const hashUtils_1 = require("../../common/hashUtils");
+const planDatabaseDeletion = (logicalId, definition, resourceType) => ({
+    logicalId,
+    action: 'delete',
+    resourceType,
+    changes: { before: definition },
+});
+const getResourceType = (database) => {
+    if (database.type === "ELASTICSEARCH_SERVERLESS" /* DatabaseEnum.ELASTICSEARCH_SERVERLESS */) {
+        return 'ALIYUN_ES_SERVERLESS';
+    }
+    else if ([
+        "RDS_MYSQL_SERVERLESS" /* DatabaseEnum.RDS_MYSQL_SERVERLESS */,
+        "RDS_PGSQL_SERVERLESS" /* DatabaseEnum.RDS_PGSQL_SERVERLESS */,
+        "RDS_MSSQL_SERVERLESS" /* DatabaseEnum.RDS_MSSQL_SERVERLESS */,
+    ].includes(database.type)) {
+        return 'ALIYUN_RDS_SERVERLESS';
+    }
+    throw new Error(`Unsupported database type: ${database.type}`);
+};
+const getDesiredDefinition = (database) => {
+    if (database.type === "ELASTICSEARCH_SERVERLESS" /* DatabaseEnum.ELASTICSEARCH_SERVERLESS */) {
+        const config = (0, esServerlessTypes_1.databaseToEsConfig)(database);
+        return (0, esServerlessTypes_1.extractEsDefinition)(config);
+    }
+    else if ([
+        "RDS_MYSQL_SERVERLESS" /* DatabaseEnum.RDS_MYSQL_SERVERLESS */,
+        "RDS_PGSQL_SERVERLESS" /* DatabaseEnum.RDS_PGSQL_SERVERLESS */,
+        "RDS_MSSQL_SERVERLESS" /* DatabaseEnum.RDS_MSSQL_SERVERLESS */,
+    ].includes(database.type)) {
+        const config = (0, rdsTypes_1.databaseToRdsConfig)(database);
+        return (0, rdsTypes_1.extractRdsDefinition)(config);
+    }
+    throw new Error(`Unsupported database type: ${database.type}`);
+};
+const generateDatabasePlan = async (context, state, databases) => {
+    // Filter databases for Aliyun RDS and ES Serverless
+    const aliyunDatabases = databases?.filter((db) => db.type === "ELASTICSEARCH_SERVERLESS" /* DatabaseEnum.ELASTICSEARCH_SERVERLESS */ ||
+        db.type === "RDS_MYSQL_SERVERLESS" /* DatabaseEnum.RDS_MYSQL_SERVERLESS */ ||
+        db.type === "RDS_PGSQL_SERVERLESS" /* DatabaseEnum.RDS_PGSQL_SERVERLESS */ ||
+        db.type === "RDS_MSSQL_SERVERLESS" /* DatabaseEnum.RDS_MSSQL_SERVERLESS */);
+    if (!aliyunDatabases || aliyunDatabases.length === 0) {
+        const allStates = (0, stateManager_1.getAllResources)(state);
+        const items = Object.entries(allStates)
+            .filter(([logicalId, resourceState]) => {
+            const resourceType = resourceState.metadata?.resourceType;
+            return (logicalId.startsWith('databases.') &&
+                (resourceType === 'ALIYUN_RDS_SERVERLESS' || resourceType === 'ALIYUN_ES_SERVERLESS'));
+        })
+            .map(([logicalId, resourceState]) => planDatabaseDeletion(logicalId, resourceState.definition, resourceState.metadata?.resourceType || 'ALIYUN_RDS_SERVERLESS'));
+        return { items };
+    }
+    const desiredLogicalIds = new Set(aliyunDatabases.map((db) => `databases.${db.key}`));
+    const client = (0, aliyunClient_1.createAliyunClient)(context);
+    const databaseItems = await Promise.all(aliyunDatabases.map(async (database) => {
+        const logicalId = `databases.${database.key}`;
+        const currentState = (0, stateManager_1.getResource)(state, logicalId);
+        const resourceType = getResourceType(database);
+        const desiredDefinition = getDesiredDefinition(database);
+        if (!currentState) {
+            return {
+                logicalId,
+                action: 'create',
+                resourceType,
+                changes: { after: desiredDefinition },
+            };
+        }
+        const instanceId = currentState.metadata?.instanceId ||
+            currentState.instances?.[0]?.id;
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            let remoteInstance = null;
+            if (resourceType === 'ALIYUN_ES_SERVERLESS') {
+                remoteInstance = instanceId ? await client.es.getApp(instanceId) : null;
+            }
+            else if (resourceType === 'ALIYUN_RDS_SERVERLESS') {
+                remoteInstance = instanceId ? await client.rds.getInstance(instanceId) : null;
+            }
+            if (!remoteInstance) {
+                return {
+                    logicalId,
+                    action: 'create',
+                    resourceType,
+                    changes: { before: currentState.definition, after: desiredDefinition },
+                    drifted: true,
+                };
+            }
+            const currentDefinition = currentState.definition || {};
+            const definitionChanged = !(0, hashUtils_1.attributesEqual)(currentDefinition, desiredDefinition);
+            if (definitionChanged) {
+                return {
+                    logicalId,
+                    action: 'update',
+                    resourceType,
+                    changes: { before: currentDefinition, after: desiredDefinition },
+                    drifted: true,
+                };
+            }
+            return { logicalId, action: 'noop', resourceType };
+        }
+        catch {
+            return {
+                logicalId,
+                action: 'create',
+                resourceType,
+                changes: { before: currentState.definition, after: desiredDefinition },
+            };
+        }
+    }));
+    const allStates = (0, stateManager_1.getAllResources)(state);
+    const deletionItems = Object.entries(allStates)
+        .filter(([logicalId, resourceState]) => {
+        const resourceType = resourceState.metadata?.resourceType;
+        return (logicalId.startsWith('databases.') &&
+            !desiredLogicalIds.has(logicalId) &&
+            (resourceType === 'ALIYUN_RDS_SERVERLESS' || resourceType === 'ALIYUN_ES_SERVERLESS'));
+    })
+        .map(([logicalId, resourceState]) => planDatabaseDeletion(logicalId, resourceState.definition, resourceState.metadata?.resourceType || 'ALIYUN_RDS_SERVERLESS'));
+    return { items: [...databaseItems, ...deletionItems] };
+};
+exports.generateDatabasePlan = generateDatabasePlan;

package/dist/src/stack/aliyunStack/databaseResource.js

@@ -0,0 +1,228 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteDatabaseResource = exports.updateDatabaseResource = exports.readDatabaseResource = exports.createDatabaseResource = void 0;
+const aliyunClient_1 = require("../../common/aliyunClient");
+const rdsTypes_1 = require("./rdsTypes");
+const esServerlessTypes_1 = require("./esServerlessTypes");
+const stateManager_1 = require("../../common/stateManager");
+const buildRdsInstanceFromProvider = (info, arn) => {
+    return {
+        arn,
+        id: info.dbInstanceId ?? '',
+        dbInstanceId: info.dbInstanceId ?? null,
+        dbInstanceDescription: info.dbInstanceDescription ?? null,
+        engine: info.engine ?? null,
+        engineVersion: info.engineVersion ?? null,
+        dbInstanceClass: info.dbInstanceClass ?? null,
+        dbInstanceStorage: info.dbInstanceStorage ?? null,
+        category: info.category ?? null,
+        dbInstanceStorageType: info.dbInstanceStorageType ?? null,
+        serverlessConfig: info.serverlessConfig
+            ? {
+                minCapacity: info.serverlessConfig.minCapacity ?? null,
+                maxCapacity: info.serverlessConfig.maxCapacity ?? null,
+                autoPause: info.serverlessConfig.autoPause ?? null,
+                switchForce: info.serverlessConfig.switchForce ?? null,
+            }
+            : {},
+        masterUsername: info.masterUsername ?? null,
+        vpcId: info.vpcId ?? null,
+        vSwitchId: info.vSwitchId ?? null,
+        zoneId: info.zoneId ?? null,
+        connectionString: info.connectionString ?? null,
+        port: info.port ?? null,
+        dbInstanceStatus: info.dbInstanceStatus ?? null,
+        createTime: info.createTime ?? null,
+        regionId: info.regionId ?? null,
+        securityIPList: info.securityIPList ?? null,
+        multiAZ: info.multiAZ ?? null,
+    };
+};
+const buildEsInstanceFromProvider = (info, arn) => {
+    return {
+        arn,
+        id: info.appId ?? '',
+        appId: info.appId ?? null,
+        appName: info.appName ?? null,
+        appType: info.appType ?? null,
+        status: info.status ?? null,
+        description: info.description ?? null,
+        createTime: info.createTime ?? null,
+        modifiedTime: info.modifiedTime ?? null,
+        regionId: info.regionId ?? null,
+        version: info.version ?? null,
+        ownerId: info.ownerId ?? null,
+        instanceId: info.instanceId ?? null,
+        chargeType: info.chargeType ?? null,
+        scenario: info.scenario ?? null,
+        network: info.network
+            ? info.network.map((n) => ({
+                type: n.type ?? null,
+                enabled: n.enabled ?? null,
+                domain: n.domain ?? null,
+                port: n.port ?? null,
+                whiteIpGroup: n.whiteIpGroup
+                    ? n.whiteIpGroup.map((w) => ({
+                        groupName: w.groupName ?? null,
+                        ips: w.ips ?? [],
+                    }))
+                    : [],
+            }))
+            : [],
+        privateNetwork: info.privateNetwork
+            ? info.privateNetwork.map((n) => ({
+                type: n.type ?? null,
+                enabled: n.enabled ?? null,
+                domain: n.domain ?? null,
+                port: n.port ?? null,
+                vpcId: n.vpcId ?? null,
+                pvlEndpointId: n.pvlEndpointId ?? null,
+                whiteIpGroup: n.whiteIpGroup
+                    ? n.whiteIpGroup.map((w) => ({
+                        groupName: w.groupName ?? null,
+                        ips: w.ips ?? [],
+                    }))
+                    : [],
+            }))
+            : [],
+        tags: info.tags
+            ? info.tags.map((t) => ({
+                key: t.key ?? null,
+                value: t.value ?? null,
+            }))
+            : [],
+    };
+};
+const createDatabaseResource = async (context, database, state) => {
+    const client = (0, aliyunClient_1.createAliyunClient)(context);
+    let instanceId;
+    let definition;
+    let instance;
+    let arn;
+    let resourceType;
+    if (database.type === "ELASTICSEARCH_SERVERLESS" /* DatabaseEnum.ELASTICSEARCH_SERVERLESS */) {
+        // Create Elasticsearch Serverless app
+        const config = (0, esServerlessTypes_1.databaseToEsConfig)(database);
+        instanceId = await client.es.createApp(config);
+        // Refresh state from provider to get all attributes
+        const appInfo = await client.es.getApp(instanceId);
+        if (!appInfo) {
+            throw new Error(`Failed to refresh state for ES app: ${instanceId}`);
+        }
+        definition = (0, esServerlessTypes_1.extractEsDefinition)(config);
+        arn = `arn:acs:elasticsearch:${context.region}:${context.accountId}:serverless:${instanceId}`;
+        instance = buildEsInstanceFromProvider(appInfo, arn);
+        resourceType = 'ALIYUN_ES_SERVERLESS';
+    }
+    else if ([
+        "RDS_MYSQL_SERVERLESS" /* DatabaseEnum.RDS_MYSQL_SERVERLESS */,
+        "RDS_PGSQL_SERVERLESS" /* DatabaseEnum.RDS_PGSQL_SERVERLESS */,
+        "RDS_MSSQL_SERVERLESS" /* DatabaseEnum.RDS_MSSQL_SERVERLESS */,
+    ].includes(database.type)) {
+        // Create RDS Serverless instance
+        const config = (0, rdsTypes_1.databaseToRdsConfig)(database);
+        instanceId = await client.rds.createInstance(config);
+        // Refresh state from provider to get all attributes
+        const rdsInfo = await client.rds.getInstance(instanceId);
+        if (!rdsInfo) {
+            throw new Error(`Failed to refresh state for RDS instance: ${instanceId}`);
+        }
+        definition = (0, rdsTypes_1.extractRdsDefinition)(config);
+        arn = `arn:acs:rds:${context.region}:${context.accountId}:dbinstance:${instanceId}`;
+        instance = buildRdsInstanceFromProvider(rdsInfo, arn);
+        resourceType = 'ALIYUN_RDS_SERVERLESS';
+    }
+    else {
+        throw new Error(`Unsupported database type: ${database.type}`);
+    }
+    const resourceState = {
+        mode: 'managed',
+        region: context.region,
+        definition,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        instances: [instance],
+        lastUpdated: new Date().toISOString(),
+        metadata: {
+            databaseName: database.name,
+            instanceId,
+            resourceType,
+        },
+    };
+    const logicalId = `databases.${database.key}`;
+    return (0, stateManager_1.setResource)(state, logicalId, resourceState);
+};
+exports.createDatabaseResource = createDatabaseResource;
+const readDatabaseResource = async (context, instanceId, resourceType) => {
+    const client = (0, aliyunClient_1.createAliyunClient)(context);
+    if (resourceType === 'ALIYUN_ES_SERVERLESS') {
+        return await client.es.getApp(instanceId);
+    }
+    else if (resourceType === 'ALIYUN_RDS_SERVERLESS') {
+        return await client.rds.getInstance(instanceId);
+    }
+    throw new Error(`Unsupported resource type: ${resourceType}`);
+};
+exports.readDatabaseResource = readDatabaseResource;
+const updateDatabaseResource = async (context, database, instanceId, resourceType, state) => {
+    const client = (0, aliyunClient_1.createAliyunClient)(context);
+    let definition;
+    let instance;
+    let arn;
+    if (resourceType === 'ALIYUN_ES_SERVERLESS') {
+        const config = (0, esServerlessTypes_1.databaseToEsConfig)(database);
+        await client.es.updateApp(instanceId, config);
+        // Refresh state from provider to get all attributes
+        const appInfo = await client.es.getApp(instanceId);
+        if (!appInfo) {
+            throw new Error(`Failed to refresh state for ES app: ${instanceId}`);
+        }
+        definition = (0, esServerlessTypes_1.extractEsDefinition)(config);
+        arn = `arn:acs:elasticsearch:${context.region}:${context.accountId}:serverless:${instanceId}`;
+        instance = buildEsInstanceFromProvider(appInfo, arn);
+    }
+    else if (resourceType === 'ALIYUN_RDS_SERVERLESS') {
+        const config = (0, rdsTypes_1.databaseToRdsConfig)(database);
+        await client.rds.updateInstance(instanceId, config);
+        // Refresh state from provider to get all attributes
+        const rdsInfo = await client.rds.getInstance(instanceId);
+        if (!rdsInfo) {
+            throw new Error(`Failed to refresh state for RDS instance: ${instanceId}`);
+        }
+        definition = (0, rdsTypes_1.extractRdsDefinition)(config);
+        arn = `arn:acs:rds:${context.region}:${context.accountId}:dbinstance:${instanceId}`;
+        instance = buildRdsInstanceFromProvider(rdsInfo, arn);
+    }
+    else {
+        throw new Error(`Unsupported resource type: ${resourceType}`);
+    }
+    const resourceState = {
+        mode: 'managed',
+        region: context.region,
+        definition,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        instances: [instance],
+        lastUpdated: new Date().toISOString(),
+        metadata: {
+            databaseName: database.name,
+            instanceId,
+            resourceType,
+        },
+    };
+    const logicalId = `databases.${database.key}`;
+    return (0, stateManager_1.setResource)(state, logicalId, resourceState);
+};
+exports.updateDatabaseResource = updateDatabaseResource;
+const deleteDatabaseResource = async (context, instanceId, resourceType, logicalId, state) => {
+    const client = (0, aliyunClient_1.createAliyunClient)(context);
+    if (resourceType === 'ALIYUN_ES_SERVERLESS') {
+        await client.es.deleteApp(instanceId);
+    }
+    else if (resourceType === 'ALIYUN_RDS_SERVERLESS') {
+        await client.rds.deleteInstance(instanceId);
+    }
+    else {
+        throw new Error(`Unsupported resource type: ${resourceType}`);
+    }
+    return (0, stateManager_1.removeResource)(state, logicalId);
+};
+exports.deleteDatabaseResource = deleteDatabaseResource;

package/dist/src/stack/aliyunStack/deployer.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deployAliyunStack = void 0;
+const common_1 = require("../../common");
+const lang_1 = require("../../lang");
+const fc3Planner_1 = require("./fc3Planner");
+const fc3Executor_1 = require("./fc3Executor");
+const ossPlanner_1 = require("./ossPlanner");
+const ossExecutor_1 = require("./ossExecutor");
+const databasePlanner_1 = require("./databasePlanner");
+const databaseExecutor_1 = require("./databaseExecutor");
+const tablestorePlanner_1 = require("./tablestorePlanner");
+const tablestoreExecutor_1 = require("./tablestoreExecutor");
+const apigwPlanner_1 = require("./apigwPlanner");
+const apigwExecutor_1 = require("./apigwExecutor");
+const createSaveStateFn = (baseDir) => (state) => {
+    (0, common_1.saveState)(state, baseDir);
+};
+const handlePartialFailure = (failure) => {
+    const error = failure.error;
+    error.isPartialFailure = true;
+    common_1.logger.error(`${lang_1.lang.__('FAILED_TO_EXECUTE_ACTION', {
+        action: failure.failedItem.action,
+        logicalId: failure.failedItem.logicalId,
+        error: error.message,
+    })}\n\n${lang_1.lang.__('PARTIAL_DEPLOYMENT_FAILURE', {
+        successCount: String(failure.successfulItems.length),
+        failedResource: failure.failedItem.logicalId,
+    })}\n${lang_1.lang.__('PARTIAL_FAILURE_STATE_SAVED')}\n${lang_1.lang.__('PARTIAL_FAILURE_NEXT_STEPS')}`);
+    throw error;
+};
+const collectSuccessfulItems = (results) => results.flatMap((result) => result.partialFailure?.successfulItems ?? []);
+const logDependencyGraph = (orderedItems, dotGraph) => {
+    common_1.logger.info(lang_1.lang.__('DEPENDENCY_GRAPH_GENERATED'));
+    common_1.logger.info(`  ${lang_1.lang.__('EXECUTION_ORDER')}:`);
+    orderedItems.forEach((item, index) => {
+        common_1.logger.info(`    ${index + 1}. ${item.logicalId} (${item.resourceType}) - ${item.action}`);
+    });
+    common_1.logger.debug(`${lang_1.lang.__('DOT_GRAPH_OUTPUT')}:\n${dotGraph}`);
+};
+const deployAliyunStack = async (iac) => {
+    const context = (0, common_1.getContext)();
+    const baseDir = process.cwd();
+    // Cache IAC for access throughout the deployment
+    (0, common_1.setIac)(iac);
+    common_1.logger.info(lang_1.lang.__('DEPLOYING_STACK_PUBLISHING_ASSETS'));
+    let state = (0, common_1.loadState)(iac.provider.name, baseDir);
+    const onStateChange = createSaveStateFn(baseDir);
+    common_1.logger.info(lang_1.lang.__('GENERATING_PLAN'));
+    const functionPlan = await (0, fc3Planner_1.generateFunctionPlan)(context, state, iac.functions);
+    const bucketPlan = await (0, ossPlanner_1.generateBucketPlan)(context, state, iac.buckets);
+    const databasePlan = await (0, databasePlanner_1.generateDatabasePlan)(context, state, iac.databases);
+    const tablePlan = await (0, tablestorePlanner_1.generateTablePlan)(context, state, iac.tables);
+    const eventPlan = await (0, apigwPlanner_1.generateApigwPlan)(context, state, iac.events, iac.service);
+    const allItems = [
+        ...functionPlan.items,
+        ...bucketPlan.items,
+        ...databasePlan.items,
+        ...tablePlan.items,
+        ...eventPlan.items,
+    ];
+    // Build dependency graph for validation (e.g. cycle detection) and logging
+    const dependencyInfo = (0, common_1.getDependencyInfo)(allItems);
+    if (dependencyInfo.cycleError) {
+        throw new Error(`${lang_1.lang.__('CYCLE_DETECTED')}: ${dependencyInfo.cycleError.cycle.join(' -> ')}`);
+    }
+    const orderedItems = dependencyInfo.order;
+    const dotGraph = (0, common_1.toDotFormat)(dependencyInfo.graph);
+    logDependencyGraph(orderedItems, dotGraph);
+    // NOTE: The dependency graph is currently used only for validation (e.g. cycle detection).
+    // Plan execution below still follows the fixed per-resource ordering.
+    common_1.logger.info(`${lang_1.lang.__('PLAN_GENERATED')}: ${allItems.length} ${lang_1.lang.__('ACTIONS')}`);
+    allItems.forEach((item) => {
+        common_1.logger.info(`  - ${item.action.toUpperCase()}: ${item.logicalId} (${item.resourceType})`);
+    });
+    common_1.logger.info(lang_1.lang.__('EXECUTING_PLAN'));
+    // Execute plans per resource type in a fixed order.
+    // The dependency graph above does not yet drive the execution sequence.
+    const functionResult = await (0, fc3Executor_1.executeFunctionPlan)(context, functionPlan, iac.functions, state, onStateChange);
+    state = functionResult.state;
+    if (functionResult.partialFailure) {
+        handlePartialFailure(functionResult.partialFailure);
+    }
+    const bucketResult = await (0, ossExecutor_1.executeBucketPlan)(context, bucketPlan, iac.buckets, state, onStateChange);
+    state = bucketResult.state;
+    if (bucketResult.partialFailure) {
+        handlePartialFailure({
+            ...bucketResult.partialFailure,
+            successfulItems: [
+                ...collectSuccessfulItems([functionResult]),
+                ...bucketResult.partialFailure.successfulItems,
+            ],
+        });
+    }
+    const databaseResult = await (0, databaseExecutor_1.executeDatabasePlan)(context, databasePlan, iac.databases, state, onStateChange);
+    state = databaseResult.state;
+    if (databaseResult.partialFailure) {
+        handlePartialFailure({
+            ...databaseResult.partialFailure,
+            successfulItems: [
+                ...collectSuccessfulItems([functionResult, bucketResult]),
+                ...databaseResult.partialFailure.successfulItems,
+            ],
+        });
+    }
+    const tableResult = await (0, tablestoreExecutor_1.executeTablePlan)(context, tablePlan, iac.tables, state, onStateChange);
+    state = tableResult.state;
+    if (tableResult.partialFailure) {
+        handlePartialFailure({
+            ...tableResult.partialFailure,
+            successfulItems: [
+                ...collectSuccessfulItems([functionResult, bucketResult, databaseResult]),
+                ...tableResult.partialFailure.successfulItems,
+            ],
+        });
+    }
+    // Execute event plan after functions are created (events depend on functions)
+    const roleArn = (0, common_1.getRoleArnFromState)(state);
+    const eventResult = await (0, apigwExecutor_1.executeApigwPlan)(context, eventPlan, iac.events, iac.service, roleArn, state, onStateChange);
+    state = eventResult.state;
+    if (eventResult.partialFailure) {
+        handlePartialFailure({
+            ...eventResult.partialFailure,
+            successfulItems: [
+                ...collectSuccessfulItems([functionResult, bucketResult, databaseResult, tableResult]),
+                ...eventResult.partialFailure.successfulItems,
+            ],
+        });
+    }
+    (0, common_1.saveState)(state, baseDir);
+    common_1.logger.info(lang_1.lang.__('STACK_DEPLOYED'));
+};
+exports.deployAliyunStack = deployAliyunStack;