@geek-fun/serverlessinsight 0.4.1 → 0.5.0

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

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.destroyAliyunStack = 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 destroyAliyunStack = async () => {
+    const context = (0, common_1.getContext)();
+    const baseDir = process.cwd();
+    const providerName = common_1.ProviderEnum.ALIYUN;
+    let state = (0, common_1.loadState)(providerName, baseDir);
+    const onStateChange = createSaveStateFn(baseDir);
+    // Set minimal IAC for destruction (function resolution not needed)
+    (0, common_1.setIac)({ version: '1.0', service: '', provider: { name: providerName, region: context.region } });
+    const functionPlan = await (0, fc3Planner_1.generateFunctionPlan)(context, state, undefined);
+    const bucketPlan = await (0, ossPlanner_1.generateBucketPlan)(context, state, undefined);
+    const databasePlan = await (0, databasePlanner_1.generateDatabasePlan)(context, state, undefined);
+    const tablePlan = await (0, tablestorePlanner_1.generateTablePlan)(context, state, undefined);
+    // For destroy, service name is not used (deletion uses state only)
+    const eventPlan = await (0, apigwPlanner_1.generateApigwPlan)(context, state, undefined, '');
+    const combinedPlan = {
+        items: [
+            ...functionPlan.items,
+            ...bucketPlan.items,
+            ...databasePlan.items,
+            ...tablePlan.items,
+            ...eventPlan.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})`);
+    });
+    // Delete events before functions (events depend on functions)
+    const roleArn = (0, common_1.getRoleArnFromState)(state);
+    const eventResult = await (0, apigwExecutor_1.executeApigwPlan)(context, eventPlan, undefined, '', // service name not needed for deletion
+    roleArn, state, onStateChange);
+    state = eventResult.state;
+    if (eventResult.partialFailure) {
+        handlePartialFailure(eventResult.partialFailure);
+    }
+    const functionResult = await (0, fc3Executor_1.executeFunctionPlan)(context, functionPlan, undefined, state, onStateChange);
+    state = functionResult.state;
+    if (functionResult.partialFailure) {
+        handlePartialFailure({
+            ...functionResult.partialFailure,
+            successfulItems: [
+                ...collectSuccessfulItems([eventResult]),
+                ...functionResult.partialFailure.successfulItems,
+            ],
+        });
+    }
+    const bucketResult = await (0, ossExecutor_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, databaseExecutor_1.executeDatabasePlan)(context, databasePlan, undefined, 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, undefined, state, onStateChange);
+    state = tableResult.state;
+    if (tableResult.partialFailure) {
+        handlePartialFailure({
+            ...tableResult.partialFailure,
+            successfulItems: [
+                ...collectSuccessfulItems([functionResult, bucketResult, databaseResult]),
+                ...tableResult.partialFailure.successfulItems,
+            ],
+        });
+    }
+    (0, common_1.saveState)(state, baseDir);
+};
+exports.destroyAliyunStack = destroyAliyunStack;

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

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractEsDefinition = exports.databaseToEsConfig = 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',
+            category: 'STANDARD',
+            quota: { minCu: 2, maxCu: 8 },
+        },
+    ],
+    [
+        `${"ELASTICSEARCH_SERVERLESS" /* DatabaseEnum.ELASTICSEARCH_SERVERLESS */}-${"ES_TIME_SERIES_7.10" /* DatabaseVersionEnum['ES_TIME_SERIES_7.10'] */}`,
+        {
+            version: '7.10',
+            category: 'TRIAL',
+            quota: { minCu: 2, maxCu: 8 },
+        },
+    ],
+]);
+const databaseToEsConfig = (database) => {
+    const engineConfig = esVersionMap.get(`${database.type}-${database.version}`);
+    if (!engineConfig) {
+        throw new Error(`Unsupported ES database type/version: ${database.type}-${database.version}`);
+    }
+    const { version, category } = engineConfig;
+    const config = {
+        appName: database.name,
+        appVersion: version,
+        authentication: {
+            basicAuth: [
+                {
+                    password: database.security.basicAuth.password,
+                    username: database.security.basicAuth.username || 'elastic',
+                },
+            ],
+        },
+        quotaInfo: {
+            appType: category,
+            cu: database.cu.min,
+            storage: database.storage.min,
+        },
+        description: `Elasticsearch serverless app: ${database.name}`,
+        chargeType: 'POSTPAY',
+    };
+    // Add network configuration for public access
+    if (database.network.type === 'PUBLIC' && database.network.ingressRules.length > 0) {
+        config.network = [
+            {
+                type: 'PUBLIC_ES',
+                enabled: true,
+                whiteIpGroup: [
+                    {
+                        groupName: 'default',
+                        ips: database.network.ingressRules,
+                    },
+                ],
+            },
+        ];
+    }
+    // Add private network configuration
+    if (database.network.type === 'PRIVATE' && database.network.vpcId) {
+        config.privateNetwork = [
+            {
+                type: 'PRIVATE_ES',
+                enabled: true,
+                vpcId: database.network.vpcId,
+                whiteIpGroup: database.network.ingressRules.length > 0
+                    ? [
+                        {
+                            groupName: 'default',
+                            ips: database.network.ingressRules,
+                        },
+                    ]
+                    : undefined,
+            },
+        ];
+    }
+    return config;
+};
+exports.databaseToEsConfig = databaseToEsConfig;
+const extractEsDefinition = (config) => {
+    return {
+        appName: config.appName,
+        appVersion: config.appVersion,
+        authentication: config.authentication
+            ? {
+                basicAuth: config.authentication.basicAuth?.map(() => ({
+                    password: '***',
+                    username: '***',
+                })),
+            }
+            : null,
+        quotaInfo: config.quotaInfo
+            ? {
+                appType: config.quotaInfo.appType ?? null,
+                cu: config.quotaInfo.cu ?? null,
+                storage: config.quotaInfo.storage ?? null,
+            }
+            : null,
+        description: config.description ?? null,
+        chargeType: config.chargeType ?? null,
+        network: config.network
+            ? config.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 ?? [],
+                    }))
+                    : null,
+            }))
+            : null,
+        privateNetwork: config.privateNetwork
+            ? config.privateNetwork.map((n) => ({
+                type: n.type ?? null,
+                enabled: n.enabled ?? null,
+                vpcId: n.vpcId ?? null,
+                pvlEndpointId: n.pvlEndpointId ?? null,
+                whiteIpGroup: n.whiteIpGroup
+                    ? n.whiteIpGroup.map((w) => ({
+                        groupName: w.groupName ?? null,
+                        ips: w.ips ?? [],
+                    }))
+                    : null,
+            }))
+            : null,
+        tags: config.tags
+            ? config.tags.map((t) => ({
+                key: t.key ?? null,
+                value: t.value ?? null,
+            }))
+            : null,
+    };
+};
+exports.extractEsDefinition = extractEsDefinition;

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

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeFunctionPlan = void 0;
+const fc3Resource_1 = require("./fc3Resource");
+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, fc3Resource_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, fc3Resource_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, fc3Resource_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/aliyunStack/fc3Planner.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateFunctionPlan = void 0;
+const common_1 = require("../../common");
+const aliyunClient_1 = require("../../common/aliyunClient");
+const fc3Types_1 = require("./fc3Types");
+const planFunctionDeletion = (logicalId, definition) => ({
+    logicalId,
+    action: 'delete',
+    resourceType: 'ALIYUN_FC3',
+    changes: { before: definition },
+});
+const generateFunctionPlan = async (context, state, functions) => {
+    if (!functions || functions.length === 0) {
+        const allStates = (0, common_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, common_1.getResource)(state, logicalId);
+        const config = (0, fc3Types_1.functionToFc3Config)(fn);
+        const codePath = fn.code.path;
+        const desiredCodeHash = (0, common_1.computeFileHash)(codePath);
+        const desiredDefinition = (0, fc3Types_1.extractFc3Definition)(config, desiredCodeHash);
+        if (!currentState) {
+            return {
+                logicalId,
+                action: 'create',
+                resourceType: 'ALIYUN_FC3',
+                changes: { after: desiredDefinition },
+            };
+        }
+        try {
+            const client = (0, aliyunClient_1.createAliyunClient)(context);
+            const remoteFunction = await client.fc3.getFunction(fn.name);
+            if (!remoteFunction) {
+                return {
+                    logicalId,
+                    action: 'create',
+                    resourceType: 'ALIYUN_FC3',
+                    changes: { before: currentState.definition, after: desiredDefinition },
+                    drifted: true,
+                };
+            }
+            const currentDefinition = currentState.definition || {};
+            const definitionChanged = !(0, common_1.attributesEqual)(currentDefinition, desiredDefinition);
+            if (definitionChanged) {
+                return {
+                    logicalId,
+                    action: 'update',
+                    resourceType: 'ALIYUN_FC3',
+                    changes: { before: currentDefinition, after: desiredDefinition },
+                    drifted: true,
+                };
+            }
+            return { logicalId, action: 'noop', resourceType: 'ALIYUN_FC3' };
+        }
+        catch {
+            return {
+                logicalId,
+                action: 'create',
+                resourceType: 'ALIYUN_FC3',
+                changes: { before: currentState.definition, after: desiredDefinition },
+            };
+        }
+    }));
+    const allStates = (0, common_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;