@geek-fun/serverlessinsight 0.6.14 → 0.7.0

package/dist/src/stack/volcengineStack/vefaasExecutor.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeFunctionPlan = void 0;
+const types_1 = require("../../types");
+const vefaasResource_1 = require("./vefaasResource");
+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(lang_1.lang.__('CREATING_RESOURCE', { resourceType: 'function', name: fn.name }));
+    const newState = await (0, vefaasResource_1.createResource)(context, fn, currentState);
+    common_1.logger.info(lang_1.lang.__('RESOURCE_CREATED', { resourceType: 'function', name: fn.name }));
+    return newState;
+};
+const executeUpdateAction = async (context, fn, currentState) => {
+    common_1.logger.info(lang_1.lang.__('UPDATING_RESOURCE', { resourceType: 'function', name: fn.name }));
+    const newState = await (0, vefaasResource_1.updateResource)(context, fn, currentState);
+    common_1.logger.info(lang_1.lang.__('RESOURCE_UPDATED', { resourceType: 'function', name: fn.name }));
+    return newState;
+};
+const executeDeleteAction = async (context, functionName, logicalId, currentState) => {
+    common_1.logger.info(lang_1.lang.__('DELETING_RESOURCE', { resourceType: 'function', name: functionName }));
+    const newState = await (0, vefaasResource_1.deleteResource)(context, functionName, logicalId, currentState);
+    common_1.logger.info(lang_1.lang.__('RESOURCE_DELETED', { resourceType: 'function', name: functionName }));
+    return newState;
+};
+const executeSingleItem = async (context, item, functionsMap, currentState) => {
+    switch (item.action) {
+        case 'noop':
+            common_1.logger.info(lang_1.lang.__('NO_CHANGESForResource', { logicalId: 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(lang_1.lang.__('STATE_NOT_FOUND_SKIPPING', { logicalId: item.logicalId }));
+                return null;
+            }
+            const functionName = state.definition.functionName;
+            return executeDeleteAction(context, functionName, item.logicalId, currentState);
+        }
+        default:
+            common_1.logger.warn(lang_1.lang.__('UNKNOWN_ACTION_FOR_RESOURCE', { action: item.action, logicalId: 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);
+                }
+            }
+        }
+        catch (error) {
+            if (error instanceof types_1.PartialResourceError) {
+                const updatedState = error.updatedState;
+                if (onStateChange) {
+                    onStateChange(updatedState);
+                }
+                return {
+                    state: updatedState,
+                    partialFailure: {
+                        failedItem: item,
+                        error: error.cause,
+                        successfulItems,
+                    },
+                };
+            }
+            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/volcengineStack/vefaasPlanner.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateFunctionPlan = void 0;
+const common_1 = require("../../common");
+const stateManager_1 = require("../../common/stateManager");
+const volcengineClient_1 = require("../../common/volcengineClient");
+const vefaasTypes_1 = require("./vefaasTypes");
+const planFunctionDeletion = (logicalId, definition) => ({
+    logicalId,
+    action: 'delete',
+    resourceType: 'VOLCENGINE_VEFAAS',
+    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, common_1.getResource)(state, logicalId);
+        const config = (0, vefaasTypes_1.functionToVefaasConfig)(fn);
+        const codePath = fn.code.path;
+        const desiredCodeHash = (0, common_1.computeFileHash)(codePath);
+        const desiredDefinition = (0, vefaasTypes_1.extractVefaasDefinition)(config, desiredCodeHash);
+        if (!currentState || currentState.status === 'tainted') {
+            return {
+                logicalId,
+                action: 'create',
+                resourceType: 'VOLCENGINE_VEFAAS',
+                changes: { after: desiredDefinition },
+            };
+        }
+        try {
+            const client = (0, volcengineClient_1.createVolcengineClient)(context);
+            const remoteFunction = await client.vefaas.getFunction(fn.name);
+            if (!remoteFunction) {
+                return {
+                    logicalId,
+                    action: 'create',
+                    resourceType: 'VOLCENGINE_VEFAAS',
+                    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: 'VOLCENGINE_VEFAAS',
+                    changes: { before: currentDefinition, after: desiredDefinition },
+                    drifted: true,
+                };
+            }
+            return { logicalId, action: 'noop', resourceType: 'VOLCENGINE_VEFAAS' };
+        }
+        catch {
+            return {
+                logicalId,
+                action: 'create',
+                resourceType: 'VOLCENGINE_VEFAAS',
+                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;