@geek-fun/serverlessinsight 0.4.0 → 0.5.0

package/dist/src/stack/scfStack/esServerlessExecutor.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeEsPlan = void 0;
+const esServerlessResource_1 = require("./esServerlessResource");
+const common_1 = require("../../common");
+const stateManager_1 = require("../../common/stateManager");
+const lang_1 = require("../../lang");
+const executeCreateAction = async (context, database, currentState) => {
+    common_1.logger.info(`Creating Tencent ES serverless space: ${database.name}`);
+    const newState = await (0, esServerlessResource_1.createEsResource)(context, database, currentState);
+    common_1.logger.info(`Successfully created Tencent ES serverless space: ${database.name}`);
+    return newState;
+};
+const executeUpdateAction = async (context, database, spaceId, currentState) => {
+    common_1.logger.info(`Updating Tencent ES serverless space: ${database.name}`);
+    const newState = await (0, esServerlessResource_1.updateEsResource)(context, database, spaceId, currentState);
+    common_1.logger.info(`Successfully updated Tencent ES serverless space: ${database.name}`);
+    return newState;
+};
+const executeDeleteAction = async (context, spaceId, logicalId, currentState) => {
+    common_1.logger.info(`Deleting Tencent ES serverless space: ${spaceId}`);
+    const newState = await (0, esServerlessResource_1.deleteEsResource)(context, spaceId, logicalId, currentState);
+    common_1.logger.info(`Successfully deleted Tencent ES serverless space: ${spaceId}`);
+    return newState;
+};
+const executeSingleItem = async (context, item, databasesMap, currentState) => {
+    if (item.resourceType !== 'TENCENT_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, 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 spaceId = state.metadata?.spaceId || state.instances?.[0]?.id;
+            if (!spaceId) {
+                throw new Error(`Space ID not found in state for ${item.logicalId}`);
+            }
+            return executeUpdateAction(context, database, spaceId, 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 spaceId = state.metadata?.spaceId || state.instances?.[0]?.id;
+            if (!spaceId) {
+                throw new Error(`Space ID not found in state for ${item.logicalId}`);
+            }
+            return executeDeleteAction(context, spaceId, item.logicalId, currentState);
+        }
+        default:
+            common_1.logger.warn(`Unknown action: ${item.action} for ${item.logicalId}`);
+            return null;
+    }
+};
+const executeEsPlan = 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.executeEsPlan = executeEsPlan;

package/dist/src/stack/scfStack/esServerlessPlanner.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateEsPlan = void 0;
+const tencentClient_1 = require("../../common/tencentClient");
+const esServerlessTypes_1 = require("./esServerlessTypes");
+const stateManager_1 = require("../../common/stateManager");
+const hashUtils_1 = require("../../common/hashUtils");
+const planEsDeletion = (logicalId, definition) => ({
+    logicalId,
+    action: 'delete',
+    resourceType: 'TENCENT_ES_SERVERLESS',
+    changes: { before: definition },
+});
+const generateEsPlan = async (context, state, databases) => {
+    const esDatabases = databases?.filter((db) => db.type === "ELASTICSEARCH_SERVERLESS" /* DatabaseEnum.ELASTICSEARCH_SERVERLESS */);
+    if (!esDatabases || esDatabases.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 === 'TENCENT_ES_SERVERLESS';
+        })
+            .map(([logicalId, resourceState]) => planEsDeletion(logicalId, resourceState.definition));
+        return { items };
+    }
+    const desiredLogicalIds = new Set(esDatabases.map((db) => `databases.${db.key}`));
+    const databaseItems = await Promise.all(esDatabases.map(async (database) => {
+        const logicalId = `databases.${database.key}`;
+        const currentState = (0, stateManager_1.getResource)(state, logicalId);
+        const config = (0, esServerlessTypes_1.databaseToTencentEsConfig)(database);
+        const desiredDefinition = (0, esServerlessTypes_1.extractTencentEsDefinition)(config);
+        if (!currentState) {
+            return {
+                logicalId,
+                action: 'create',
+                resourceType: 'TENCENT_ES_SERVERLESS',
+                changes: { after: desiredDefinition },
+            };
+        }
+        const spaceId = currentState.metadata?.spaceId || currentState.instances?.[0]?.id;
+        try {
+            const client = (0, tencentClient_1.createTencentClient)(context);
+            const remoteSpace = spaceId ? await client.es.getSpace(spaceId) : null;
+            if (!remoteSpace) {
+                return {
+                    logicalId,
+                    action: 'create',
+                    resourceType: 'TENCENT_ES_SERVERLESS',
+                    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: 'TENCENT_ES_SERVERLESS',
+                    changes: { before: currentDefinition, after: desiredDefinition },
+                    drifted: true,
+                };
+            }
+            return { logicalId, action: 'noop', resourceType: 'TENCENT_ES_SERVERLESS' };
+        }
+        catch {
+            return {
+                logicalId,
+                action: 'create',
+                resourceType: 'TENCENT_ES_SERVERLESS',
+                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 === 'TENCENT_ES_SERVERLESS');
+    })
+        .map(([logicalId, resourceState]) => planEsDeletion(logicalId, resourceState.definition));
+    return { items: [...databaseItems, ...deletionItems] };
+};
+exports.generateEsPlan = generateEsPlan;

package/dist/src/stack/scfStack/esServerlessResource.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteEsResource = exports.updateEsResource = exports.readEsResource = exports.createEsResource = void 0;
+const tencentClient_1 = require("../../common/tencentClient");
+const esServerlessTypes_1 = require("./esServerlessTypes");
+const stateManager_1 = require("../../common/stateManager");
+const buildEsSpaceFromProvider = (info, arn) => {
+    return {
+        arn,
+        id: info.SpaceId,
+        spaceId: info.SpaceId,
+        spaceName: info.SpaceName,
+        status: info.Status,
+        createTime: info.CreateTime ?? null,
+        indexCount: info.IndexCount ?? null,
+        kibanaUrl: info.KibanaUrl ?? null,
+        kibanaPrivateUrl: info.KibanaPrivateUrl ?? null,
+    };
+};
+const createEsResource = async (context, database, state) => {
+    const config = (0, esServerlessTypes_1.databaseToTencentEsConfig)(database);
+    const client = (0, tencentClient_1.createTencentClient)(context);
+    const spaceId = await client.es.createSpace({
+        SpaceName: config.SpaceName,
+        VpcInfo: config.VpcId && config.SubnetId
+            ? [{ VpcId: config.VpcId, SubnetId: config.SubnetId }]
+            : undefined,
+        Zone: config.Zone,
+        KibanaWhiteIpList: config.KibanaWhiteIpList,
+    });
+    // Refresh state from provider to get all attributes
+    const spaceInfo = await client.es.getSpace(spaceId);
+    if (!spaceInfo) {
+        throw new Error(`Failed to refresh state for ES space: ${spaceId}`);
+    }
+    const definition = (0, esServerlessTypes_1.extractTencentEsDefinition)(config);
+    const arn = `arn:tencent:es:${context.region}::space:${spaceId}`;
+    const resourceState = {
+        mode: 'managed',
+        region: context.region,
+        definition,
+        instances: [buildEsSpaceFromProvider(spaceInfo, arn)],
+        lastUpdated: new Date().toISOString(),
+        metadata: {
+            spaceName: database.name,
+            spaceId,
+            resourceType: 'TENCENT_ES_SERVERLESS',
+        },
+    };
+    const logicalId = `databases.${database.key}`;
+    return (0, stateManager_1.setResource)(state, logicalId, resourceState);
+};
+exports.createEsResource = createEsResource;
+const readEsResource = async (context, spaceId) => {
+    const client = (0, tencentClient_1.createTencentClient)(context);
+    return await client.es.getSpace(spaceId);
+};
+exports.readEsResource = readEsResource;
+const updateEsResource = async (context, database, spaceId, state) => {
+    const config = (0, esServerlessTypes_1.databaseToTencentEsConfig)(database);
+    const client = (0, tencentClient_1.createTencentClient)(context);
+    await client.es.updateSpace(spaceId, {
+        SpaceName: config.SpaceName,
+        KibanaWhiteIpList: config.KibanaWhiteIpList,
+    });
+    // Refresh state from provider to get all attributes
+    const spaceInfo = await client.es.getSpace(spaceId);
+    if (!spaceInfo) {
+        throw new Error(`Failed to refresh state for ES space: ${spaceId}`);
+    }
+    const definition = (0, esServerlessTypes_1.extractTencentEsDefinition)(config);
+    const arn = `arn:tencent:es:${context.region}::space:${spaceId}`;
+    const resourceState = {
+        mode: 'managed',
+        region: context.region,
+        definition,
+        instances: [buildEsSpaceFromProvider(spaceInfo, arn)],
+        lastUpdated: new Date().toISOString(),
+        metadata: {
+            spaceName: database.name,
+            spaceId,
+            resourceType: 'TENCENT_ES_SERVERLESS',
+        },
+    };
+    const logicalId = `databases.${database.key}`;
+    return (0, stateManager_1.setResource)(state, logicalId, resourceState);
+};
+exports.updateEsResource = updateEsResource;
+const deleteEsResource = async (context, spaceId, logicalId, state) => {
+    const client = (0, tencentClient_1.createTencentClient)(context);
+    await client.es.deleteSpace(spaceId);
+    return (0, stateManager_1.removeResource)(state, logicalId);
+};
+exports.deleteEsResource = deleteEsResource;

package/dist/src/stack/scfStack/esServerlessTypes.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractTencentEsDefinition = exports.databaseToTencentEsConfig = void 0;
+// Map database versions to ES versions
+const esVersionMap = new Map([
+    [
+        `${"ELASTICSEARCH_SERVERLESS" /* DatabaseEnum.ELASTICSEARCH_SERVERLESS */}-${"ES_SEARCH_7.10" /* DatabaseVersionEnum['ES_SEARCH_7.10'] */}`,
+        { version: '7.10' },
+    ],
+    [
+        `${"ELASTICSEARCH_SERVERLESS" /* DatabaseEnum.ELASTICSEARCH_SERVERLESS */}-${"ES_TIME_SERIES_7.10" /* DatabaseVersionEnum['ES_TIME_SERIES_7.10'] */}`,
+        { version: '7.10' },
+    ],
+]);
+const databaseToTencentEsConfig = (database) => {
+    const engineConfig = esVersionMap.get(`${database.type}-${database.version}`);
+    if (!engineConfig) {
+        throw new Error(`Unsupported ES database type/version: ${database.type}-${database.version}`);
+    }
+    const config = {
+        SpaceName: database.name,
+        Version: engineConfig.version,
+    };
+    // Add network configuration
+    if (database.network.vpcId) {
+        config.VpcId = database.network.vpcId;
+    }
+    if (database.network.subnetId) {
+        config.SubnetId = database.network.subnetId;
+    }
+    // Add IP whitelist from ingress rules for public access
+    if (database.network.ingressRules && database.network.ingressRules.length > 0) {
+        config.KibanaWhiteIpList = database.network.ingressRules;
+    }
+    return config;
+};
+exports.databaseToTencentEsConfig = databaseToTencentEsConfig;
+const extractTencentEsDefinition = (config) => {
+    return {
+        spaceName: config.SpaceName,
+        version: config.Version ?? null,
+        vpcId: config.VpcId ?? null,
+        subnetId: config.SubnetId ?? null,
+        zone: config.Zone ?? null,
+        kibanaWhiteIpList: config.KibanaWhiteIpList ?? null,
+    };
+};
+exports.extractTencentEsDefinition = extractTencentEsDefinition;

package/dist/src/stack/scfStack/index.js

@@ -0,0 +1,35 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./scfTypes"), exports);
+__exportStar(require("./scfResource"), exports);
+__exportStar(require("./scfPlanner"), exports);
+__exportStar(require("./scfExecutor"), exports);
+__exportStar(require("./cosTypes"), exports);
+__exportStar(require("./cosResource"), exports);
+__exportStar(require("./cosPlanner"), exports);
+__exportStar(require("./cosExecutor"), exports);
+__exportStar(require("./tdsqlcTypes"), exports);
+__exportStar(require("./tdsqlcResource"), exports);
+__exportStar(require("./tdsqlcPlanner"), exports);
+__exportStar(require("./tdsqlcExecutor"), exports);
+__exportStar(require("./esServerlessTypes"), exports);
+__exportStar(require("./esServerlessResource"), exports);
+__exportStar(require("./esServerlessPlanner"), exports);
+__exportStar(require("./esServerlessExecutor"), exports);
+__exportStar(require("./deployer"), exports);
+__exportStar(require("./destroyer"), exports);
+__exportStar(require("./planner"), exports);

package/dist/src/stack/scfStack/planner.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.displayPlan = exports.generateTencentPlan = void 0;
+const common_1 = require("../../common");
+const lang_1 = require("../../lang");
+const scfPlanner_1 = require("./scfPlanner");
+const cosPlanner_1 = require("./cosPlanner");
+const tdsqlcPlanner_1 = require("./tdsqlcPlanner");
+const esServerlessPlanner_1 = require("./esServerlessPlanner");
+const generateTencentPlan = async (iac) => {
+    const context = (0, common_1.getContext)();
+    const state = (0, common_1.loadState)(iac.provider.name, process.cwd());
+    const functionPlan = await (0, scfPlanner_1.generateFunctionPlan)(context, state, iac.functions);
+    const bucketPlan = await (0, cosPlanner_1.generateBucketPlan)(context, state, iac.buckets);
+    const databasePlan = await (0, tdsqlcPlanner_1.generateDatabasePlan)(context, state, iac.databases);
+    const esPlan = await (0, esServerlessPlanner_1.generateEsPlan)(context, state, iac.databases);
+    const allItems = [
+        ...functionPlan.items,
+        ...bucketPlan.items,
+        ...databasePlan.items,
+        ...esPlan.items,
+    ];
+    const dependencyInfo = (0, common_1.getDependencyInfo)(allItems);
+    if (dependencyInfo.cycleError) {
+        throw new Error(`${lang_1.lang.__('CYCLE_DETECTED')}: ${dependencyInfo.cycleError.cycle.join(' -> ')}`);
+    }
+    return {
+        items: dependencyInfo.order,
+        levels: dependencyInfo.levels,
+        graph: dependencyInfo.graph,
+        dotGraph: (0, common_1.toDotFormat)(dependencyInfo.graph),
+    };
+};
+exports.generateTencentPlan = generateTencentPlan;
+const displayPlan = (planResult) => {
+    const separator = '========================================';
+    if (planResult.items.length === 0) {
+        common_1.logger.info(`${separator}\n${lang_1.lang.__('DEPLOYMENT_PLAN')}\n${separator}\n${lang_1.lang.__('NO_CHANGES_INFRASTRUCTURE_UP_TO_DATE')}`);
+        return;
+    }
+    const createActions = planResult.items.filter((item) => item.action === 'create');
+    const updateActions = planResult.items.filter((item) => item.action === 'update');
+    const deleteActions = planResult.items.filter((item) => item.action === 'delete');
+    const noopActions = planResult.items.filter((item) => item.action === 'noop');
+    const sections = [];
+    if (createActions.length > 0) {
+        const createLines = [`[${lang_1.lang.__('CREATE')}]:`];
+        for (const item of createActions) {
+            createLines.push(`  + ${item.logicalId} (${item.resourceType})`);
+            if (item.changes?.after) {
+                const jsonStr = JSON.stringify(item.changes.after, null, 2);
+                createLines.push(`    ${jsonStr.split('\n').join('\n    ')}`);
+            }
+        }
+        sections.push(createLines.join('\n'));
+    }
+    if (updateActions.length > 0) {
+        const updateLines = [`[${lang_1.lang.__('UPDATE')}]:`];
+        for (const item of updateActions) {
+            updateLines.push(`  ~ ${item.logicalId} (${item.resourceType})`);
+            if (item.drifted) {
+                updateLines.push(`    [${lang_1.lang.__('DRIFTED')}] ${lang_1.lang.__('REMOTE_CONFIG_DIFFERS')}`);
+            }
+            if (item.changes) {
+                const jsonStr = JSON.stringify(item.changes, null, 2);
+                updateLines.push(`    ${lang_1.lang.__('CHANGES')}: ${jsonStr.split('\n').join('\n    ')}`);
+            }
+        }
+        sections.push(updateLines.join('\n'));
+    }
+    if (deleteActions.length > 0) {
+        const deleteLines = [`[${lang_1.lang.__('DELETE')}]:`];
+        for (const item of deleteActions) {
+            deleteLines.push(`  - ${item.logicalId} (${item.resourceType})`);
+            if (item.changes?.before) {
+                const jsonStr = JSON.stringify(item.changes.before, null, 2);
+                deleteLines.push(`    ${jsonStr.split('\n').join('\n    ')}`);
+            }
+        }
+        sections.push(deleteLines.join('\n'));
+    }
+    if (noopActions.length > 0) {
+        const noopLines = [`[${lang_1.lang.__('NO_CHANGE')}]:`];
+        for (const item of noopActions) {
+            noopLines.push(`  = ${item.logicalId} (${item.resourceType})`);
+        }
+        sections.push(noopLines.join('\n'));
+    }
+    common_1.logger.info(`\n${separator}\n${lang_1.lang.__('DEPLOYMENT_PLAN')}\n${separator}\n${sections.join('\n\n')}\n\n${separator}\n${lang_1.lang.__('PLAN')}: ${createActions.length} ${lang_1.lang.__('TO_CREATE')}, ${updateActions.length} ${lang_1.lang.__('TO_UPDATE')}, ${deleteActions.length} ${lang_1.lang.__('TO_DELETE')}, ${noopActions.length} ${lang_1.lang.__('UNCHANGED')}\n${separator}`);
+};
+exports.displayPlan = displayPlan;

package/dist/src/stack/scfStack/scfExecutor.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeFunctionPlan = void 0;
+const scfResource_1 = require("./scfResource");
+const common_1 = require("../../common");
+const stateManager_1 = require("../../common/stateManager");
+const lang_1 = require("../../lang");
+const executeCreateAction = async (context, fn, currentState) => {
+    common_1.logger.info(`Creating function: ${fn.name}`);
+    const newState = await (0, scfResource_1.createResource)(context, fn, currentState);
+    common_1.logger.info(`Successfully created function: ${fn.name}`);
+    return newState;
+};
+const executeUpdateAction = async (context, fn, currentState) => {
+    common_1.logger.info(`Updating function: ${fn.name}`);
+    const newState = await (0, scfResource_1.updateResource)(context, fn, currentState);
+    common_1.logger.info(`Successfully updated function: ${fn.name}`);
+    return newState;
+};
+const executeDeleteAction = async (context, functionName, logicalId, currentState) => {
+    common_1.logger.info(`Deleting function: ${functionName}`);
+    const newState = await (0, scfResource_1.deleteResource)(context, functionName, logicalId, currentState);
+    common_1.logger.info(`Successfully deleted function: ${functionName}`);
+    return newState;
+};
+const executeSingleItem = async (context, item, functionsMap, currentState) => {
+    switch (item.action) {
+        case 'noop':
+            common_1.logger.info(`No changes for ${item.logicalId}`);
+            return null;
+        case 'create': {
+            const fn = functionsMap.get(item.logicalId);
+            if (!fn) {
+                throw new Error(`Function not found for logical ID: ${item.logicalId}`);
+            }
+            return executeCreateAction(context, fn, currentState);
+        }
+        case 'update': {
+            const fn = functionsMap.get(item.logicalId);
+            if (!fn) {
+                throw new Error(`Function not found for logical ID: ${item.logicalId}`);
+            }
+            return executeUpdateAction(context, fn, 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 functionName = state.definition.functionName;
+            return executeDeleteAction(context, functionName, item.logicalId, currentState);
+        }
+        default:
+            common_1.logger.warn(`Unknown action: ${item.action} for ${item.logicalId}`);
+            return null;
+    }
+};
+const executeFunctionPlan = async (context, plan, functions, initialState, onStateChange) => {
+    const functionsMap = new Map(functions?.map((fn) => [`functions.${fn.key}`, fn]) ?? []);
+    const successfulItems = [];
+    let currentState = initialState;
+    for (const item of plan.items) {
+        try {
+            const newState = await executeSingleItem(context, item, functionsMap, 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.executeFunctionPlan = executeFunctionPlan;

package/dist/src/stack/scfStack/scfPlanner.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateFunctionPlan = void 0;
+const tencentClient_1 = require("../../common/tencentClient");
+const scfTypes_1 = require("./scfTypes");
+const stateManager_1 = require("../../common/stateManager");
+const hashUtils_1 = require("../../common/hashUtils");
+const planFunctionDeletion = (logicalId, definition) => ({
+    logicalId,
+    action: 'delete',
+    resourceType: 'SCF',
+    changes: { before: definition },
+});
+const generateFunctionPlan = async (context, state, functions) => {
+    if (!functions || functions.length === 0) {
+        const allStates = (0, stateManager_1.getAllResources)(state);
+        const items = Object.entries(allStates)
+            .filter(([logicalId]) => logicalId.startsWith('functions.'))
+            .map(([logicalId, resourceState]) => planFunctionDeletion(logicalId, resourceState.definition));
+        return { items };
+    }
+    const desiredLogicalIds = new Set(functions.map((fn) => `functions.${fn.key}`));
+    const functionItems = await Promise.all(functions.map(async (fn) => {
+        const logicalId = `functions.${fn.key}`;
+        const currentState = (0, stateManager_1.getResource)(state, logicalId);
+        const config = (0, scfTypes_1.functionToScfConfig)(fn);
+        const codePath = fn.code.path;
+        const desiredCodeHash = (0, hashUtils_1.computeFileHash)(codePath);
+        const desiredDefinition = (0, scfTypes_1.extractScfDefinition)(config, desiredCodeHash);
+        if (!currentState) {
+            return {
+                logicalId,
+                action: 'create',
+                resourceType: 'SCF',
+                changes: { after: desiredDefinition },
+            };
+        }
+        try {
+            const client = (0, tencentClient_1.createTencentClient)(context);
+            const remoteFunction = await client.scf.getFunction(fn.name);
+            if (!remoteFunction) {
+                return {
+                    logicalId,
+                    action: 'create',
+                    resourceType: 'SCF',
+                    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: 'SCF',
+                    changes: { before: currentDefinition, after: desiredDefinition },
+                    drifted: true,
+                };
+            }
+            return { logicalId, action: 'noop', resourceType: 'SCF' };
+        }
+        catch {
+            return {
+                logicalId,
+                action: 'create',
+                resourceType: 'SCF',
+                changes: { before: currentState.definition, after: desiredDefinition },
+            };
+        }
+    }));
+    const allStates = (0, stateManager_1.getAllResources)(state);
+    const deletionItems = Object.entries(allStates)
+        .filter(([logicalId]) => logicalId.startsWith('functions.') && !desiredLogicalIds.has(logicalId))
+        .map(([logicalId, resourceState]) => planFunctionDeletion(logicalId, resourceState.definition));
+    return { items: [...functionItems, ...deletionItems] };
+};
+exports.generateFunctionPlan = generateFunctionPlan;