@geek-fun/serverlessinsight 0.6.14 → 0.7.0

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

@@ -579,9 +579,24 @@ const updateResource = async (context, fn, state) => {
         };
     }
     const codePath = fn.code.path;
-    await client.fc3.updateFunctionConfiguration(config);
-    const ossCode = await ensureOssCodeUpload(client, codePath, context.region, fn.name);
-    await client.fc3.updateFunctionCode(fn.name, codePath, ossCode);
+    const currentCodeHash = existingState?.definition?.codeHash;
+    const desiredCodeHash = (0, common_1.computeFileHash)(codePath);
+    const codeChanged = currentCodeHash !== desiredCodeHash;
+    const existingConfig = existingState?.definition;
+    const desiredDefinition = (0, fc3Types_1.extractFc3Definition)(config, desiredCodeHash);
+    const { codeHash: _existingCodeHash, ...existingConfigOnly } = existingConfig || {};
+    const { codeHash: _desiredCodeHash, ...desiredConfigOnly } = desiredDefinition;
+    const configChanged = !(0, common_1.attributesEqual)(existingConfigOnly, desiredConfigOnly);
+    if (configChanged) {
+        await client.fc3.updateFunctionConfiguration(config);
+    }
+    if (codeChanged) {
+        const ossCode = await ensureOssCodeUpload(client, codePath, context.region, fn.name);
+        await client.fc3.updateFunctionCode(fn.name, codePath, ossCode);
+    }
+    if (!configChanged && !codeChanged) {
+        logger_1.logger.warn(lang_1.lang.__('UPDATING_RESOURCE_WITH_NO_CHANGES', { resourceType: 'function', name: fn.name }));
+    }
     const functionInfo = await client.fc3.getFunction(fn.name);
     if (!functionInfo) {
         throw new Error(`Failed to refresh state for function: ${fn.name}`);

package/dist/src/stack/deploy.js

@@ -4,6 +4,7 @@ exports.deployStack = void 0;
 const common_1 = require("../common");
 const scfStack_1 = require("./scfStack");
 const aliyunStack_1 = require("./aliyunStack");
+const volcengineStack_1 = require("./volcengineStack");
 const deployHuawei = async () => {
     throw new Error('Huawei deployment is not yet implemented. ' +
         'The provider currently generates HCL templates but does not deploy them. ' +
@@ -19,5 +20,8 @@ const deployStack = async (iac, backend) => {
     else if (iac.provider.name === common_1.ProviderEnum.HUAWEI) {
         await deployHuawei();
     }
+    else if (iac.provider.name === common_1.ProviderEnum.VOLCENGINE) {
+        await (0, volcengineStack_1.deployVolcengineStack)(iac, backend);
+    }
 };
 exports.deployStack = deployStack;

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

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeApigwPlan = void 0;
+const apigwResource_1 = require("./apigwResource");
+const common_1 = require("../../common");
+const stateManager_1 = require("../../common/stateManager");
+const lang_1 = require("../../lang");
+const executeSingleItem = async (context, item, eventsMap, serviceName, currentState) => {
+    switch (item.action) {
+        case 'noop':
+            common_1.logger.info(lang_1.lang.__('NO_CHANGESForResource', { logicalId: item.logicalId }));
+            return null;
+        case 'create': {
+            const event = eventsMap.get(item.logicalId);
+            if (!event) {
+                throw new Error(`Event not found for logical ID: ${item.logicalId}`);
+            }
+            common_1.logger.info(lang_1.lang.__('CREATING_RESOURCE', { resourceType: 'API Gateway resources', name: event.name }));
+            const newState = await (0, apigwResource_1.createApigwResource)(context, event, serviceName, currentState);
+            common_1.logger.info(lang_1.lang.__('RESOURCE_CREATED', { resourceType: 'API Gateway resources', name: event.name }));
+            return newState;
+        }
+        case 'update': {
+            const event = eventsMap.get(item.logicalId);
+            if (!event) {
+                throw new Error(`Event not found for logical ID: ${item.logicalId}`);
+            }
+            common_1.logger.info(lang_1.lang.__('UPDATING_RESOURCE', { resourceType: 'API Gateway resources', name: event.name }));
+            const newState = await (0, apigwResource_1.updateApigwResource)(context, event, serviceName, currentState);
+            common_1.logger.info(lang_1.lang.__('RESOURCE_UPDATED', { resourceType: 'API Gateway resources', name: event.name }));
+            return newState;
+        }
+        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;
+            }
+            common_1.logger.info(lang_1.lang.__('DELETING_RESOURCE', {
+                resourceType: 'API Gateway resources',
+                name: item.logicalId,
+            }));
+            const newState = await (0, apigwResource_1.deleteApigwResource)(context, item.logicalId, currentState);
+            common_1.logger.info(lang_1.lang.__('RESOURCE_DELETED', {
+                resourceType: 'API Gateway resources',
+                name: item.logicalId,
+            }));
+            return newState;
+        }
+        default:
+            common_1.logger.warn(lang_1.lang.__('UNKNOWN_ACTION_FOR_RESOURCE', { action: item.action, logicalId: item.logicalId }));
+            return null;
+    }
+};
+const executeApigwPlan = async (context, plan, events, serviceName, initialState, onStateChange) => {
+    const eventsMap = new Map(events?.map((e) => [`events.${e.key}`, e]) ?? []);
+    const successfulItems = [];
+    let currentState = initialState;
+    for (const item of plan.items) {
+        try {
+            const newState = await executeSingleItem(context, item, eventsMap, serviceName, 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.executeApigwPlan = executeApigwPlan;

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

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateApigwPlan = void 0;
+const volcengineClient_1 = require("../../common/volcengineClient");
+const apigwTypes_1 = require("./apigwTypes");
+const stateManager_1 = require("../../common/stateManager");
+const hashUtils_1 = require("../../common/hashUtils");
+const planEventDeletion = (logicalId, definition) => ({
+    logicalId,
+    action: 'delete',
+    resourceType: 'VOLCENGINE_APIGW',
+    changes: { before: definition },
+});
+const generateApigwPlan = async (context, state, events, serviceName) => {
+    if (!events || events.length === 0) {
+        const allStates = (0, stateManager_1.getAllResources)(state);
+        const items = Object.entries(allStates)
+            .filter(([logicalId]) => logicalId.startsWith('events.'))
+            .map(([logicalId, resourceState]) => planEventDeletion(logicalId, resourceState.definition));
+        return { items };
+    }
+    const desiredLogicalIds = new Set(events.map((e) => `events.${e.key}`));
+    const eventItems = await Promise.all(events.map(async (event) => {
+        const logicalId = `events.${event.key}`;
+        const currentState = (0, stateManager_1.getResource)(state, logicalId);
+        const groupConfig = (0, apigwTypes_1.eventToApigwGroupConfig)(event, serviceName, context.stage);
+        const groupDefinition = (0, apigwTypes_1.extractApigwGroupDefinition)(groupConfig);
+        const client = (0, volcengineClient_1.createVolcengineClient)(context);
+        const desiredDefinition = {
+            ...groupDefinition,
+            triggers: event.triggers.map((t) => ({
+                method: t.method,
+                path: t.path,
+                backend: t.backend,
+            })),
+            domain: (0, apigwTypes_1.extractEventDomainDefinition)(event.domain),
+        };
+        if (!currentState) {
+            try {
+                const remoteGateway = await client.apigw.findGatewayByName(groupConfig.groupName);
+                if (remoteGateway) {
+                    return {
+                        logicalId,
+                        action: 'update',
+                        resourceType: 'VOLCENGINE_APIGW',
+                        changes: { after: desiredDefinition },
+                        drifted: true,
+                    };
+                }
+            }
+            catch {
+                // Ignore errors when checking remote
+            }
+            return {
+                logicalId,
+                action: 'create',
+                resourceType: 'VOLCENGINE_APIGW',
+                changes: { after: desiredDefinition },
+            };
+        }
+        try {
+            const groupInstance = currentState.instances.find((i) => i.type === 'VOLCENGINE_APIGW_GROUP');
+            if (groupInstance) {
+                const remoteGateway = await client.apigw.getGateway(groupInstance.id);
+                if (!remoteGateway) {
+                    return {
+                        logicalId,
+                        action: 'create',
+                        resourceType: 'VOLCENGINE_APIGW',
+                        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: 'VOLCENGINE_APIGW',
+                    changes: { before: currentDefinition, after: desiredDefinition },
+                };
+            }
+            return { logicalId, action: 'noop', resourceType: 'VOLCENGINE_APIGW' };
+        }
+        catch {
+            return {
+                logicalId,
+                action: 'create',
+                resourceType: 'VOLCENGINE_APIGW',
+                changes: { before: currentState.definition, after: desiredDefinition },
+            };
+        }
+    }));
+    const allStates = (0, stateManager_1.getAllResources)(state);
+    const deletionItems = Object.entries(allStates)
+        .filter(([logicalId]) => {
+        if (!logicalId.startsWith('events.')) {
+            return false;
+        }
+        if (desiredLogicalIds.has(logicalId)) {
+            return false;
+        }
+        return true;
+    })
+        .map(([logicalId, resourceState]) => planEventDeletion(logicalId, resourceState.definition));
+    return { items: [...eventItems, ...deletionItems] };
+};
+exports.generateApigwPlan = generateApigwPlan;

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

@@ -0,0 +1,302 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteApigwResource = exports.updateApigwResource = exports.readApigwResourceByName = exports.readApigwResource = exports.createApigwResource = void 0;
+const volcengineClient_1 = require("../../common/volcengineClient");
+const apigwTypes_1 = require("./apigwTypes");
+const stateManager_1 = require("../../common/stateManager");
+const common_1 = require("../../common");
+const logger_1 = require("../../common/logger");
+const lang_1 = require("../../lang");
+const buildApigwGroupInstanceFromProvider = (info, stage) => {
+    return {
+        type: 'VOLCENGINE_APIGW_GROUP',
+        sid: (0, common_1.buildSid)('volcengine', 'apigw', stage, info.gatewayId ?? ''),
+        id: info.gatewayId ?? '',
+        gatewayId: info.gatewayId ?? null,
+        gatewayName: info.gatewayName ?? null,
+        description: info.description ?? null,
+        protocol: info.protocol ?? null,
+        status: info.status ?? null,
+        createdTime: info.createdTime ?? null,
+        subDomain: info.subDomain ?? null,
+    };
+};
+const buildApigwApiInstanceFromProvider = (info, stage, gatewayId) => {
+    return {
+        type: 'VOLCENGINE_APIGW_API',
+        sid: (0, common_1.buildSid)('volcengine', 'apigw', stage, `${gatewayId}/${info.apiId}`),
+        id: info.apiId ?? '',
+        apiId: info.apiId ?? null,
+        apiName: info.apiName ?? null,
+        gatewayId: info.gatewayId ?? null,
+        method: info.method ?? null,
+        path: info.path ?? null,
+        description: info.description ?? null,
+        backendType: info.backendType ?? null,
+        backendFunctionName: info.backendFunctionName ?? null,
+        status: info.status ?? null,
+        createdTime: info.createdTime ?? null,
+    };
+};
+const buildApigwDeploymentInstance = (gatewayId, apiId, stageName, stage) => {
+    return {
+        type: 'VOLCENGINE_APIGW_DEPLOYMENT',
+        sid: (0, common_1.buildSid)('volcengine', 'apigw', stage, `${gatewayId}/${apiId}/${stageName}`),
+        id: `${gatewayId}/${apiId}/${stageName}`,
+        gatewayId,
+        apiId,
+        stageName,
+    };
+};
+const createApigwResource = async (context, event, serviceName, state) => {
+    const logicalId = `events.${event.key}`;
+    const client = (0, volcengineClient_1.createVolcengineClient)(context);
+    const groupConfig = (0, apigwTypes_1.eventToApigwGroupConfig)(event, serviceName, context.stage);
+    let gatewayId;
+    try {
+        const existingGateway = await client.apigw.findGatewayByName(groupConfig.groupName);
+        if (existingGateway?.gatewayId) {
+            logger_1.logger.info(lang_1.lang.__('APIGW_GROUP_FOUND_REUSING', { groupName: groupConfig.groupName }));
+            gatewayId = existingGateway.gatewayId;
+        }
+        else {
+            const gatewayInfo = await client.apigw.createGateway(groupConfig);
+            gatewayId = gatewayInfo.gatewayId;
+        }
+    }
+    catch (error) {
+        logger_1.logger.debug(`Could not find existing gateway, creating new: ${error}`);
+        const gatewayInfo = await client.apigw.createGateway(groupConfig);
+        gatewayId = gatewayInfo.gatewayId;
+    }
+    const gatewayInfo = await client.apigw.getGateway(gatewayId);
+    if (!gatewayInfo) {
+        throw new Error(`Failed to get API Gateway info after creation: ${gatewayId}`);
+    }
+    const instances = [
+        buildApigwGroupInstanceFromProvider(gatewayInfo, context.stage),
+    ];
+    const groupDefinition = (0, apigwTypes_1.extractApigwGroupDefinition)(groupConfig);
+    const partialResourceState = {
+        mode: 'managed',
+        region: context.region,
+        definition: {
+            ...groupDefinition,
+            triggers: event.triggers.map((t) => ({
+                method: t.method,
+                path: t.path,
+                backend: t.backend,
+            })),
+            domain: (0, apigwTypes_1.extractEventDomainDefinition)(event.domain),
+        },
+        instances,
+        lastUpdated: new Date().toISOString(),
+    };
+    state = (0, stateManager_1.setResource)(state, logicalId, partialResourceState);
+    for (const trigger of event.triggers) {
+        const apiConfig = (0, apigwTypes_1.triggerToApigwApiConfig)(event, trigger, gatewayId, serviceName, context.region, context.stage);
+        const apiId = await client.apigw.createApi(apiConfig);
+        const apiInfo = await client.apigw.getApi(gatewayId, apiId);
+        if (apiInfo) {
+            instances.push(buildApigwApiInstanceFromProvider(apiInfo, context.stage, gatewayId));
+        }
+        await client.apigw.deployApi(gatewayId, apiId);
+        instances.push(buildApigwDeploymentInstance(gatewayId, apiId, 'RELEASE', context.stage));
+        const updatedResourceState = {
+            mode: 'managed',
+            region: context.region,
+            definition: {
+                ...groupDefinition,
+                triggers: event.triggers.map((t) => ({
+                    method: t.method,
+                    path: t.path,
+                    backend: t.backend,
+                })),
+                domain: (0, apigwTypes_1.extractEventDomainDefinition)(event.domain),
+            },
+            instances,
+            lastUpdated: new Date().toISOString(),
+        };
+        state = (0, stateManager_1.setResource)(state, logicalId, updatedResourceState);
+    }
+    if (event.domain) {
+        try {
+            const domainConfig = {
+                gatewayId,
+                domainName: event.domain.domain_name,
+                certificateId: event.domain.certificate_id,
+            };
+            await client.apigw.bindDomain(domainConfig);
+        }
+        catch (error) {
+            logger_1.logger.error(lang_1.lang.__('APIGW_DOMAIN_BINDING_FAILED', { error: String(error) }));
+            logger_1.logger.info(lang_1.lang.__('APIGW_GROUP_APIS_CREATED_DOMAIN_FAILED'));
+            logger_1.logger.info(lang_1.lang.__('APIGW_STATE_SAVED_RETRY'));
+            return state;
+        }
+    }
+    const finalResourceState = {
+        mode: 'managed',
+        region: context.region,
+        definition: {
+            ...groupDefinition,
+            triggers: event.triggers.map((t) => ({
+                method: t.method,
+                path: t.path,
+                backend: t.backend,
+            })),
+            domain: (0, apigwTypes_1.extractEventDomainDefinition)(event.domain),
+        },
+        instances,
+        lastUpdated: new Date().toISOString(),
+    };
+    return (0, stateManager_1.setResource)(state, logicalId, finalResourceState);
+};
+exports.createApigwResource = createApigwResource;
+const readApigwResource = async (context, gatewayId) => {
+    const client = (0, volcengineClient_1.createVolcengineClient)(context);
+    return await client.apigw.getGateway(gatewayId);
+};
+exports.readApigwResource = readApigwResource;
+const readApigwResourceByName = async (context, gatewayName) => {
+    const client = (0, volcengineClient_1.createVolcengineClient)(context);
+    return await client.apigw.findGatewayByName(gatewayName);
+};
+exports.readApigwResourceByName = readApigwResourceByName;
+const updateApigwResource = async (context, event, serviceName, state) => {
+    const logicalId = `events.${event.key}`;
+    const existingState = (0, stateManager_1.getResource)(state, logicalId);
+    const client = (0, volcengineClient_1.createVolcengineClient)(context);
+    if (!existingState) {
+        return (0, exports.createApigwResource)(context, event, serviceName, state);
+    }
+    const existingInstances = existingState.instances;
+    const groupInstance = existingInstances.find((i) => i.type === 'VOLCENGINE_APIGW_GROUP');
+    if (!groupInstance) {
+        return (0, exports.createApigwResource)(context, event, serviceName, state);
+    }
+    const gatewayId = groupInstance.id;
+    const groupConfig = (0, apigwTypes_1.eventToApigwGroupConfig)(event, serviceName, context.stage);
+    await client.apigw.updateGateway(gatewayId, groupConfig);
+    const gatewayInfo = await client.apigw.getGateway(gatewayId);
+    if (!gatewayInfo) {
+        throw new Error(`Failed to get API Gateway info after update: ${gatewayId}`);
+    }
+    const instances = [
+        buildApigwGroupInstanceFromProvider(gatewayInfo, context.stage),
+    ];
+    const existingApis = existingInstances.filter((i) => i.type === 'VOLCENGINE_APIGW_API');
+    const neededApiKeys = new Set();
+    for (const trigger of event.triggers) {
+        const apiConfig = (0, apigwTypes_1.triggerToApigwApiConfig)(event, trigger, gatewayId, serviceName, context.region, context.stage);
+        const apiKey = (0, apigwTypes_1.generateApiKey)(trigger.method, trigger.path);
+        neededApiKeys.add(apiKey);
+        const existingApi = existingApis.find((a) => {
+            return a.id && a.apiName === apiConfig.apiName;
+        });
+        let apiId;
+        if (existingApi) {
+            apiId = existingApi.id;
+            await client.apigw.updateApi(apiId, apiConfig);
+        }
+        else {
+            apiId = await client.apigw.createApi(apiConfig);
+        }
+        const apiInfo = await client.apigw.getApi(gatewayId, apiId);
+        if (apiInfo) {
+            instances.push(buildApigwApiInstanceFromProvider(apiInfo, context.stage, gatewayId));
+        }
+        await client.apigw.deployApi(gatewayId, apiId);
+        instances.push(buildApigwDeploymentInstance(gatewayId, apiId, 'RELEASE', context.stage));
+    }
+    for (const existingApi of existingApis) {
+        const apiInfo = await client.apigw.getApi(gatewayId, existingApi.id);
+        if (apiInfo) {
+            const isNeeded = event.triggers.some((t) => {
+                const expectedName = (0, apigwTypes_1.triggerToApigwApiConfig)(event, t, gatewayId, serviceName, context.region, context.stage).apiName;
+                return apiInfo.apiName === expectedName;
+            });
+            if (!isNeeded) {
+                await client.apigw.deleteApi(gatewayId, existingApi.id);
+            }
+        }
+    }
+    if (event.domain) {
+        const domainConfig = {
+            gatewayId,
+            domainName: event.domain.domain_name,
+            certificateId: event.domain.certificate_id,
+        };
+        await client.apigw.bindDomain(domainConfig);
+    }
+    else {
+        const existingDomain = existingState.definition?.domain;
+        if (existingDomain?.domainName) {
+            const previousDomain = existingDomain.domainName;
+            try {
+                await client.apigw.unbindDomain(gatewayId, previousDomain);
+            }
+            catch (error) {
+                logger_1.logger.warn(lang_1.lang.__('APIGW_DOMAIN_UNBIND_FAILED', { domain: previousDomain, error: String(error) }));
+            }
+        }
+    }
+    const groupDefinition = (0, apigwTypes_1.extractApigwGroupDefinition)(groupConfig);
+    const resourceState = {
+        mode: 'managed',
+        region: context.region,
+        definition: {
+            ...groupDefinition,
+            triggers: event.triggers.map((t) => ({
+                method: t.method,
+                path: t.path,
+                backend: t.backend,
+            })),
+            domain: (0, apigwTypes_1.extractEventDomainDefinition)(event.domain),
+        },
+        instances,
+        lastUpdated: new Date().toISOString(),
+    };
+    return (0, stateManager_1.setResource)(state, logicalId, resourceState);
+};
+exports.updateApigwResource = updateApigwResource;
+const deleteApigwResource = async (context, logicalId, state) => {
+    const existingState = (0, stateManager_1.getResource)(state, logicalId);
+    const client = (0, volcengineClient_1.createVolcengineClient)(context);
+    if (!existingState) {
+        return state;
+    }
+    const existingInstances = existingState.instances;
+    const groupInstance = existingInstances.find((i) => i.type === 'VOLCENGINE_APIGW_GROUP');
+    if (!groupInstance) {
+        return (0, stateManager_1.removeResource)(state, logicalId);
+    }
+    const gatewayId = groupInstance.id;
+    const existingDomain = existingState.definition?.domain;
+    if (existingDomain?.domainName) {
+        const primaryDomain = existingDomain.domainName;
+        try {
+            await client.apigw.unbindDomain(gatewayId, primaryDomain);
+        }
+        catch (error) {
+            logger_1.logger.warn(lang_1.lang.__('APIGW_DOMAIN_UNBIND_FAILED', { domain: primaryDomain, error: String(error) }));
+        }
+    }
+    const apis = existingInstances.filter((i) => i.type === 'VOLCENGINE_APIGW_API');
+    for (const api of apis) {
+        try {
+            await client.apigw.deleteApi(gatewayId, api.id);
+        }
+        catch {
+            // API might already be deleted
+        }
+    }
+    try {
+        await client.apigw.deleteGateway(gatewayId);
+    }
+    catch {
+        // Gateway might already be deleted
+    }
+    return (0, stateManager_1.removeResource)(state, logicalId);
+};
+exports.deleteApigwResource = deleteApigwResource;

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

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractEventDomainDefinition = exports.extractApigwApiDefinition = exports.extractApigwGroupDefinition = exports.triggerToApigwApiConfig = exports.generateApiKey = exports.eventToApigwGroupConfig = void 0;
+const common_1 = require("../../common");
+const lang_1 = require("../../lang");
+/**
+ * Convert EventDomain to API Gateway group config
+ */
+const eventToApigwGroupConfig = (event, serviceName, stage) => {
+    return {
+        groupName: `${serviceName}-${stage}-apigw`.replace(/_/g, '-'),
+        description: `API Gateway for ${serviceName}`,
+        protocol: event.domain?.protocol ?? 'HTTP',
+    };
+};
+exports.eventToApigwGroupConfig = eventToApigwGroupConfig;
+/**
+ * Generate a unique API key from method and path
+ * Uses URL encoding to preserve path structure and avoid collisions
+ */
+const generateApiKey = (method, path) => {
+    const sanitizedPath = path
+        .replace(/\//g, '__')
+        .replace(/[^a-zA-Z0-9_]/g, '_')
+        .replace(/^__/, '')
+        .replace(/__$/, '');
+    return `${method}_${sanitizedPath}`;
+};
+exports.generateApiKey = generateApiKey;
+/**
+ * Resolves a function reference like ${functions.xxx} to the actual function name
+ */
+const resolveFunctionReference = (backendRef) => {
+    const context = (0, common_1.getContext)();
+    if (!context.iac) {
+        common_1.logger.warn(lang_1.lang.__('CANNOT_RESOLVE_FUNCTION_REF', { backendRef }));
+        return backendRef;
+    }
+    const functionDef = (0, common_1.getIacDefinition)(context.iac, backendRef);
+    if (!functionDef || !(0, common_1.isFunctionDomain)(functionDef)) {
+        common_1.logger.warn(lang_1.lang.__('FUNCTION_REF_NOT_RESOLVED', { backendRef }));
+        return backendRef;
+    }
+    const functionName = functionDef.name;
+    common_1.logger.info(lang_1.lang.__('RESOLVED_FUNCTION_REF', { backendRef, functionName }));
+    return functionName;
+};
+/**
+ * Convert EventDomain trigger to API Gateway API config
+ */
+const triggerToApigwApiConfig = (event, trigger, gatewayId, _serviceName, _region, stage) => {
+    const method = trigger.method;
+    const path = trigger.path;
+    const backend = trigger.backend;
+    const resolvedFunctionName = resolveFunctionReference(backend);
+    const apiKey = (0, exports.generateApiKey)(method, path);
+    return {
+        gatewayId,
+        apiName: `${event.name}-${stage}-api-${apiKey}`.replace(/_/g, '-'),
+        method,
+        path,
+        backendFunctionName: resolvedFunctionName,
+        backendType: 'veFaaS',
+        requestTimeout: 60,
+    };
+};
+exports.triggerToApigwApiConfig = triggerToApigwApiConfig;
+/**
+ * Extract definition from API Gateway group config for state comparison
+ */
+const extractApigwGroupDefinition = (config) => {
+    return {
+        groupName: config.groupName,
+        description: config.description ?? null,
+        protocol: config.protocol ?? null,
+    };
+};
+exports.extractApigwGroupDefinition = extractApigwGroupDefinition;
+/**
+ * Extract definition from API Gateway API config for state comparison
+ */
+const extractApigwApiDefinition = (config) => {
+    return {
+        apiName: config.apiName,
+        gatewayId: config.gatewayId,
+        method: config.method,
+        path: config.path,
+        backendFunctionName: config.backendFunctionName,
+        backendType: config.backendType,
+    };
+};
+exports.extractApigwApiDefinition = extractApigwApiDefinition;
+const extractEventDomainDefinition = (domain) => {
+    if (!domain) {
+        return null;
+    }
+    return {
+        domainName: domain.domain_name,
+        wwwBindApex: domain.www_bind_apex === true,
+        certificateId: domain.certificate_id ?? null,
+        certificateBody: domain.certificate_body ?? null,
+        certificatePrivateKey: domain.certificate_private_key ? '(managed)' : null,
+        protocol: domain.protocol ?? null,
+    };
+};
+exports.extractEventDomainDefinition = extractEventDomainDefinition;