@geek-fun/serverlessinsight 0.4.0 → 0.5.0

package/dist/src/stack/localStack/function.js

@@ -10,8 +10,12 @@ const node_path_1 = __importDefault(require("node:path"));
 const node_fs_1 = __importDefault(require("node:fs"));
 const aliyunFc_1 = require("./aliyunFc");
 const utils_1 = require("./utils");
+const lang_1 = require("../../lang");
 const functionsHandler = async (req, parsed, iac) => {
-    common_1.logger.info(`Function request received by local server -> ${req.method} ${parsed.identifier ?? '/'} `);
+    common_1.logger.info(lang_1.lang.__('FUNCTION_REQUEST_RECEIVED', {
+        method: req.method || '',
+        identifier: parsed.identifier ?? '/',
+    }));
     const fcDef = iac.functions?.find((fn) => fn.key === parsed.identifier);
     if (!fcDef) {
         return {
@@ -44,7 +48,7 @@ const functionsHandler = async (req, parsed, iac) => {
             functionKey: fcDef.key,
             handler: fcDef.code.handler,
             servicePath: '',
-            timeout: fcDef.timeout * 1000,
+            timeout: (fcDef.timeout ?? 3) * 1000,
         };
         // Check if provider is Aliyun to use Aliyun FC format
         const isAliyun = iac.provider.name === common_1.ProviderEnum.ALIYUN;
@@ -57,7 +61,7 @@ const functionsHandler = async (req, parsed, iac) => {
             const { event: aliyunEvent } = await (0, aliyunFc_1.transformToAliyunEvent)(req, parsed.url, parsed.query);
             event = aliyunEvent;
             // Use serializable context for worker thread (logger will be added inside worker)
-            fcContext = (0, aliyunFc_1.createAliyunContextSerializable)(iac, fcDef.name, fcDef.code.handler, fcDef.memory, fcDef.timeout, requestId);
+            fcContext = (0, aliyunFc_1.createAliyunContextSerializable)(iac, fcDef.name, fcDef.code.handler, fcDef.memory ?? 128, fcDef.timeout ?? 3, requestId);
             env = {
                 ...fcDef.environment,
             };
@@ -83,10 +87,12 @@ const functionsHandler = async (req, parsed, iac) => {
                 awsRequestId: Math.random().toString(36).substring(2, 15),
             };
         }
-        common_1.logger.debug(`Invoking worker with event type: ${isAliyun ? 'Buffer' : 'Object'} and context`);
-        common_1.logger.debug(`Worker codeDir: ${codeDir}, handler: ${funOptions.handler}`);
+        common_1.logger.debug(lang_1.lang.__('INVOKING_WORKER_WITH_EVENT_TYPE', {
+            eventType: isAliyun ? 'Buffer' : 'Object',
+        }));
+        common_1.logger.debug(lang_1.lang.__('WORKER_CODE_DIR', { codeDir, handler: funOptions.handler }));
         const result = await (0, functionRunner_1.invokeFunction)(funOptions, env, event, fcContext);
-        common_1.logger.info(`Function execution result: ${JSON.stringify(result)}`);
+        common_1.logger.info(lang_1.lang.__('FUNCTION_EXECUTION_RESULT', { result: JSON.stringify(result) }));
         // For Aliyun, transform FC response to HTTP response if needed
         if (isAliyun && result) {
             const transformed = (0, aliyunFc_1.transformFCResponse)(result);
@@ -102,7 +108,7 @@ const functionsHandler = async (req, parsed, iac) => {
         };
     }
     catch (error) {
-        common_1.logger.error(`Function execution error: ${error}`);
+        common_1.logger.error(lang_1.lang.__('FUNCTION_EXECUTION_ERROR', { error: String(error) }));
         return {
             statusCode: 500,
             body: {

package/dist/src/stack/localStack/functionRunner.js

@@ -169,7 +169,7 @@ const resolveWorkerPath = () => {
         return localPath;
     }
     // Fallback to dist directory
-    const distPath = __dirname.replace(/src\/stack\/localStack$/, 'dist/src/stack/localStack');
+    const distPath = __dirname.replace((0, node_path_1.join)('src', 'stack', 'localStack'), (0, node_path_1.join)('dist', 'src', 'stack', 'localStack'));
     return (0, node_path_1.join)(distPath, 'functionRunner.js');
 };
 const createWorker = (funOptions, env) => {

package/dist/src/stack/localStack/localServer.js

@@ -7,6 +7,7 @@ exports.stopLocal = exports.servLocal = void 0;
 const localStack_1 = require("../../types/localStack");
 const common_1 = require("../../common");
 const node_http_1 = __importDefault(require("node:http"));
+const lang_1 = require("../../lang");
 let localServer;
 const cleanPathSegments = (pathname) => pathname
     .split('/')
@@ -43,7 +44,7 @@ const parseRequest = (req) => {
 };
 const servLocal = async (handlers, iac) => {
     if (localServer) {
-        common_1.logger.info(`localServer already running on http://localhost:${common_1.SI_LOCALSTACK_SERVER_PORT}`);
+        common_1.logger.info(lang_1.lang.__('LOCAL_SERVER_ALREADY_RUNNING', { port: String(common_1.SI_LOCALSTACK_SERVER_PORT) }));
         return;
     }
     localServer = node_http_1.default.createServer(async (req, res) => {
@@ -76,13 +77,13 @@ const servLocal = async (handlers, iac) => {
             }
         }
         catch (err) {
-            common_1.logger.error({ err }, 'Local gateway error');
+            common_1.logger.error({ err }, lang_1.lang.__('LOCAL_GATEWAY_ERROR'));
             respondJson(res, 500, { error: 'Local gateway failure' });
         }
     });
     await new Promise((resolve, reject) => {
         localServer.listen(common_1.SI_LOCALSTACK_SERVER_PORT, '0.0.0.0', () => {
-            common_1.logger.info(`Local Server listening on http://localhost:${common_1.SI_LOCALSTACK_SERVER_PORT}`);
+            common_1.logger.info(lang_1.lang.__('LOCAL_SERVER_LISTENING', { port: String(common_1.SI_LOCALSTACK_SERVER_PORT) }));
             resolve();
         });
         localServer.once('error', reject);
@@ -91,18 +92,18 @@ const servLocal = async (handlers, iac) => {
 exports.servLocal = servLocal;
 const stopLocal = async () => {
     if (!localServer) {
-        common_1.logger.info('localServer is not running');
+        common_1.logger.info(lang_1.lang.__('LOCAL_SERVER_NOT_RUNNING'));
         return;
     }
     await new Promise((resolve, reject) => {
         localServer.close((err) => {
             if (err) {
-                common_1.logger.error({ err }, 'Error stopping localServer');
+                common_1.logger.error({ err }, lang_1.lang.__('ERROR_STOPPING_LOCAL_SERVER'));
                 reject(err);
             }
             else {
                 localServer = undefined;
-                common_1.logger.info('localServer stopped');
+                common_1.logger.info(lang_1.lang.__('LOCAL_SERVER_STOPPED'));
                 resolve();
             }
         });

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

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

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

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateBucketPlan = void 0;
+const tencentClient_1 = require("../../common/tencentClient");
+const cosTypes_1 = require("./cosTypes");
+const stateManager_1 = require("../../common/stateManager");
+const hashUtils_1 = require("../../common/hashUtils");
+const planBucketDeletion = (logicalId, definition) => ({
+    logicalId,
+    action: 'delete',
+    resourceType: 'COS_BUCKET',
+    changes: { before: definition },
+});
+const generateBucketPlan = async (context, state, buckets) => {
+    if (!buckets || buckets.length === 0) {
+        const allStates = (0, stateManager_1.getAllResources)(state);
+        const items = Object.entries(allStates)
+            .filter(([logicalId]) => logicalId.startsWith('buckets.'))
+            .map(([logicalId, resourceState]) => planBucketDeletion(logicalId, resourceState.definition));
+        return { items };
+    }
+    const desiredLogicalIds = new Set(buckets.map((bucket) => `buckets.${bucket.key}`));
+    const bucketItems = await Promise.all(buckets.map(async (bucket) => {
+        const logicalId = `buckets.${bucket.key}`;
+        const currentState = (0, stateManager_1.getResource)(state, logicalId);
+        const config = (0, cosTypes_1.bucketToCosBucketConfig)(bucket, context.region);
+        const desiredDefinition = (0, cosTypes_1.extractCosBucketDefinition)(config);
+        if (!currentState) {
+            return {
+                logicalId,
+                action: 'create',
+                resourceType: 'COS_BUCKET',
+                changes: { after: desiredDefinition },
+            };
+        }
+        try {
+            const client = (0, tencentClient_1.createTencentClient)(context);
+            const remoteBucket = await client.cos.getBucket(bucket.name, context.region);
+            if (!remoteBucket) {
+                return {
+                    logicalId,
+                    action: 'create',
+                    resourceType: 'COS_BUCKET',
+                    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: 'COS_BUCKET',
+                    changes: { before: currentDefinition, after: desiredDefinition },
+                    drifted: true,
+                };
+            }
+            return { logicalId, action: 'noop', resourceType: 'COS_BUCKET' };
+        }
+        catch {
+            return {
+                logicalId,
+                action: 'create',
+                resourceType: 'COS_BUCKET',
+                changes: { before: currentState.definition, after: desiredDefinition },
+            };
+        }
+    }));
+    const allStates = (0, stateManager_1.getAllResources)(state);
+    const deletionItems = Object.entries(allStates)
+        .filter(([logicalId]) => logicalId.startsWith('buckets.') && !desiredLogicalIds.has(logicalId))
+        .map(([logicalId, resourceState]) => planBucketDeletion(logicalId, resourceState.definition));
+    return { items: [...bucketItems, ...deletionItems] };
+};
+exports.generateBucketPlan = generateBucketPlan;

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

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteBucketResource = exports.updateBucketResource = exports.readBucketResource = exports.createBucketResource = void 0;
+const tencentClient_1 = require("../../common/tencentClient");
+const cosTypes_1 = require("./cosTypes");
+const stateManager_1 = require("../../common/stateManager");
+const buildCosInstanceFromProvider = (info, arn) => {
+    return {
+        arn,
+        id: info.Name,
+        bucket: info.Name,
+        location: info.Location,
+        creationDate: info.CreationDate ?? null,
+        acl: info.ACL ?? null,
+        websiteConfiguration: info.WebsiteConfiguration
+            ? {
+                indexDocument: info.WebsiteConfiguration.IndexDocument?.Suffix ?? null,
+                errorDocument: info.WebsiteConfiguration.ErrorDocument?.Key ?? null,
+            }
+            : {},
+        accessControlPolicy: info.AccessControlPolicy
+            ? {
+                owner: info.AccessControlPolicy.owner
+                    ? {
+                        id: info.AccessControlPolicy.owner.id ?? null,
+                        displayName: info.AccessControlPolicy.owner.displayName ?? null,
+                    }
+                    : {},
+                grants: info.AccessControlPolicy.grants?.map((g) => ({
+                    grantee: g.grantee
+                        ? {
+                            type: g.grantee.type ?? null,
+                            uri: g.grantee.uri ?? null,
+                            id: g.grantee.id ?? null,
+                            displayName: g.grantee.displayName ?? null,
+                        }
+                        : {},
+                    permission: g.permission ?? null,
+                })) ?? [],
+            }
+            : {},
+        corsConfiguration: info.CorsConfiguration?.map((r) => ({
+            id: r.id ?? null,
+            allowedOrigins: r.allowedOrigins ?? [],
+            allowedMethods: r.allowedMethods ?? [],
+            allowedHeaders: r.allowedHeaders ?? [],
+            exposeHeaders: r.exposeHeaders ?? [],
+            maxAgeSeconds: r.maxAgeSeconds ?? null,
+        })) ?? [],
+        versioningConfiguration: info.VersioningConfiguration
+            ? {
+                status: info.VersioningConfiguration.status ?? null,
+            }
+            : {},
+        taggingConfiguration: info.TaggingConfiguration
+            ? {
+                tags: info.TaggingConfiguration.tags?.map((t) => ({
+                    key: t.key ?? null,
+                    value: t.value ?? null,
+                })) ?? [],
+            }
+            : {},
+    };
+};
+const createBucketResource = async (context, bucket, state) => {
+    const config = (0, cosTypes_1.bucketToCosBucketConfig)(bucket, context.region);
+    const client = (0, tencentClient_1.createTencentClient)(context);
+    await client.cos.createBucket(config);
+    // Refresh state from provider to get all attributes
+    const bucketInfo = await client.cos.getBucket(bucket.name, context.region);
+    if (!bucketInfo) {
+        throw new Error(`Failed to refresh state for bucket: ${bucket.name}`);
+    }
+    const definition = (0, cosTypes_1.extractCosBucketDefinition)(config);
+    const arn = `arn:tencent:cos:${context.region}::bucket:${bucket.name}`;
+    const resourceState = {
+        mode: 'managed',
+        region: context.region,
+        definition,
+        instances: [buildCosInstanceFromProvider(bucketInfo, arn)],
+        lastUpdated: new Date().toISOString(),
+    };
+    const logicalId = `buckets.${bucket.key}`;
+    return (0, stateManager_1.setResource)(state, logicalId, resourceState);
+};
+exports.createBucketResource = createBucketResource;
+const readBucketResource = async (context, bucketName, region) => {
+    const client = (0, tencentClient_1.createTencentClient)(context);
+    return await client.cos.getBucket(bucketName, region);
+};
+exports.readBucketResource = readBucketResource;
+const updateBucketResource = async (context, bucket, state) => {
+    const config = (0, cosTypes_1.bucketToCosBucketConfig)(bucket, context.region);
+    const client = (0, tencentClient_1.createTencentClient)(context);
+    // Update ACL if specified
+    if (config.ACL) {
+        await client.cos.updateBucketAcl(bucket.name, context.region, config.ACL);
+    }
+    // Update website configuration if specified
+    if (config.WebsiteConfiguration) {
+        await client.cos.updateBucketWebsite(bucket.name, context.region, config.WebsiteConfiguration);
+    }
+    // Refresh state from provider to get all attributes
+    const bucketInfo = await client.cos.getBucket(bucket.name, context.region);
+    if (!bucketInfo) {
+        throw new Error(`Failed to refresh state for bucket: ${bucket.name}`);
+    }
+    const definition = (0, cosTypes_1.extractCosBucketDefinition)(config);
+    const arn = `arn:tencent:cos:${context.region}::bucket:${bucket.name}`;
+    const resourceState = {
+        mode: 'managed',
+        region: context.region,
+        definition,
+        instances: [buildCosInstanceFromProvider(bucketInfo, arn)],
+        lastUpdated: new Date().toISOString(),
+    };
+    const logicalId = `buckets.${bucket.key}`;
+    return (0, stateManager_1.setResource)(state, logicalId, resourceState);
+};
+exports.updateBucketResource = updateBucketResource;
+const deleteBucketResource = async (context, bucketName, region, logicalId, state) => {
+    const client = (0, tencentClient_1.createTencentClient)(context);
+    await client.cos.deleteBucket(bucketName, region);
+    return (0, stateManager_1.removeResource)(state, logicalId);
+};
+exports.deleteBucketResource = deleteBucketResource;

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

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractCosBucketDefinition = exports.bucketToCosBucketConfig = void 0;
+const bucketToCosBucketConfig = (bucket, region) => {
+    const config = {
+        Bucket: bucket.name,
+        Region: region,
+    };
+    if (bucket.security?.acl) {
+        const aclMap = {
+            PRIVATE: 'private',
+            PUBLIC_READ: 'public-read',
+            PUBLIC_READ_WRITE: 'public-read-write',
+        };
+        config.ACL = aclMap[bucket.security.acl];
+    }
+    if (bucket.website) {
+        config.WebsiteConfiguration = {
+            IndexDocument: {
+                Suffix: bucket.website.index,
+            },
+        };
+        // Only add ErrorDocument if error_page is defined
+        if (bucket.website.error_page) {
+            config.WebsiteConfiguration.ErrorDocument = {
+                Key: bucket.website.error_page,
+            };
+        }
+    }
+    return config;
+};
+exports.bucketToCosBucketConfig = bucketToCosBucketConfig;
+const extractCosBucketDefinition = (config) => {
+    return {
+        bucket: config.Bucket,
+        region: config.Region,
+        acl: config.ACL ?? null,
+        websiteConfiguration: config.WebsiteConfiguration
+            ? {
+                indexDocument: config.WebsiteConfiguration.IndexDocument.Suffix,
+                errorDocument: config.WebsiteConfiguration.ErrorDocument?.Key ?? null,
+            }
+            : {},
+    };
+};
+exports.extractCosBucketDefinition = extractCosBucketDefinition;

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

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deployTencentStack = void 0;
+const common_1 = require("../../common");
+const lang_1 = require("../../lang");
+const scfPlanner_1 = require("./scfPlanner");
+const scfExecutor_1 = require("./scfExecutor");
+const cosPlanner_1 = require("./cosPlanner");
+const cosExecutor_1 = require("./cosExecutor");
+const tdsqlcPlanner_1 = require("./tdsqlcPlanner");
+const tdsqlcExecutor_1 = require("./tdsqlcExecutor");
+const esServerlessPlanner_1 = require("./esServerlessPlanner");
+const esServerlessExecutor_1 = require("./esServerlessExecutor");
+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 deployTencentStack = async (iac) => {
+    const context = (0, common_1.getContext)();
+    const baseDir = process.cwd();
+    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, 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 combinedPlan = {
+        items: [...functionPlan.items, ...bucketPlan.items, ...databasePlan.items, ...esPlan.items],
+    };
+    common_1.logger.info(`${lang_1.lang.__('PLAN_GENERATED')}: ${combinedPlan.items.length} ${lang_1.lang.__('ACTIONS')}`);
+    combinedPlan.items.forEach((item) => {
+        common_1.logger.info(`  - ${item.action.toUpperCase()}: ${item.logicalId} (${item.resourceType})`);
+    });
+    common_1.logger.info(lang_1.lang.__('EXECUTING_PLAN'));
+    const functionResult = await (0, scfExecutor_1.executeFunctionPlan)(context, functionPlan, iac.functions, state, onStateChange);
+    state = functionResult.state;
+    if (functionResult.partialFailure) {
+        handlePartialFailure(functionResult.partialFailure);
+    }
+    const bucketResult = await (0, cosExecutor_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, tdsqlcExecutor_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 esResult = await (0, esServerlessExecutor_1.executeEsPlan)(context, esPlan, iac.databases, state, onStateChange);
+    state = esResult.state;
+    if (esResult.partialFailure) {
+        handlePartialFailure({
+            ...esResult.partialFailure,
+            successfulItems: [
+                ...collectSuccessfulItems([functionResult, bucketResult, databaseResult]),
+                ...esResult.partialFailure.successfulItems,
+            ],
+        });
+    }
+    (0, common_1.saveState)(state, baseDir);
+    common_1.logger.info(lang_1.lang.__('STACK_DEPLOYED'));
+};
+exports.deployTencentStack = deployTencentStack;

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

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.destroyTencentStack = void 0;
+const common_1 = require("../../common");
+const lang_1 = require("../../lang");
+const scfPlanner_1 = require("./scfPlanner");
+const scfExecutor_1 = require("./scfExecutor");
+const cosPlanner_1 = require("./cosPlanner");
+const cosExecutor_1 = require("./cosExecutor");
+const tdsqlcPlanner_1 = require("./tdsqlcPlanner");
+const tdsqlcExecutor_1 = require("./tdsqlcExecutor");
+const esServerlessPlanner_1 = require("./esServerlessPlanner");
+const esServerlessExecutor_1 = require("./esServerlessExecutor");
+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 failure.error;
+};
+const collectSuccessfulItems = (results) => results.flatMap((result) => result.partialFailure?.successfulItems ?? []);
+const destroyTencentStack = async () => {
+    const context = (0, common_1.getContext)();
+    const baseDir = process.cwd();
+    const providerName = common_1.ProviderEnum.TENCENT;
+    let state = (0, common_1.loadState)(providerName, baseDir);
+    const onStateChange = createSaveStateFn(baseDir);
+    const functionPlan = await (0, scfPlanner_1.generateFunctionPlan)(context, state, undefined);
+    const bucketPlan = await (0, cosPlanner_1.generateBucketPlan)(context, state, undefined);
+    const databasePlan = await (0, tdsqlcPlanner_1.generateDatabasePlan)(context, state, undefined);
+    const esPlan = await (0, esServerlessPlanner_1.generateEsPlan)(context, state, undefined);
+    const combinedPlan = {
+        items: [...functionPlan.items, ...bucketPlan.items, ...databasePlan.items, ...esPlan.items],
+    };
+    common_1.logger.info(`${lang_1.lang.__('PLAN_GENERATED')}: ${combinedPlan.items.length} ${lang_1.lang.__('ACTIONS')}`);
+    combinedPlan.items.forEach((item) => {
+        common_1.logger.info(`  - ${item.action.toUpperCase()}: ${item.logicalId} (${item.resourceType})`);
+    });
+    const functionResult = await (0, scfExecutor_1.executeFunctionPlan)(context, functionPlan, undefined, state, onStateChange);
+    state = functionResult.state;
+    if (functionResult.partialFailure) {
+        handlePartialFailure(functionResult.partialFailure);
+    }
+    const bucketResult = await (0, cosExecutor_1.executeBucketPlan)(context, bucketPlan, undefined, state, onStateChange);
+    state = bucketResult.state;
+    if (bucketResult.partialFailure) {
+        handlePartialFailure({
+            ...bucketResult.partialFailure,
+            successfulItems: [
+                ...collectSuccessfulItems([functionResult]),
+                ...bucketResult.partialFailure.successfulItems,
+            ],
+        });
+    }
+    const databaseResult = await (0, tdsqlcExecutor_1.executeDatabasePlan)(context, databasePlan, undefined, state, onStateChange);
+    state = databaseResult.state;
+    if (databaseResult.partialFailure) {
+        handlePartialFailure({
+            ...databaseResult.partialFailure,
+            successfulItems: [
+                ...collectSuccessfulItems([functionResult, bucketResult]),
+                ...databaseResult.partialFailure.successfulItems,
+            ],
+        });
+    }
+    const esResult = await (0, esServerlessExecutor_1.executeEsPlan)(context, esPlan, undefined, state, onStateChange);
+    state = esResult.state;
+    if (esResult.partialFailure) {
+        handlePartialFailure({
+            ...esResult.partialFailure,
+            successfulItems: [
+                ...collectSuccessfulItems([functionResult, bucketResult, databaseResult]),
+                ...esResult.partialFailure.successfulItems,
+            ],
+        });
+    }
+    (0, common_1.saveState)(state, baseDir);
+};
+exports.destroyTencentStack = destroyTencentStack;