@geek-fun/serverlessinsight 0.4.0 → 0.5.0

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

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateApigwPlan = void 0;
+const aliyunClient_1 = require("../../common/aliyunClient");
+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: 'ALIYUN_APIGW',
+    changes: { before: definition },
+});
+/**
+ * Generate plan for API Gateway events
+ */
+const generateApigwPlan = async (context, state, events, serviceName) => {
+    // If no events, check if we need to delete existing ones
+    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);
+        const groupDefinition = (0, apigwTypes_1.extractApigwGroupDefinition)(groupConfig);
+        const client = (0, aliyunClient_1.createAliyunClient)(context);
+        // Build desired definition including triggers
+        const desiredDefinition = {
+            ...groupDefinition,
+            triggers: event.triggers.map((t) => ({
+                method: t.method,
+                path: t.path,
+                backend: t.backend,
+            })),
+            domain: event.domain
+                ? {
+                    domainName: event.domain.domain_name,
+                    certificateName: event.domain.certificate_name,
+                }
+                : null,
+        };
+        if (!currentState) {
+            // No state exists, check if resource exists remotely
+            try {
+                const remoteGroup = await client.apigw.findApiGroupByName(groupConfig.groupName);
+                if (remoteGroup) {
+                    // Resource exists remotely but not in state - this is drift
+                    // We should update (import) it rather than try to create again
+                    return {
+                        logicalId,
+                        action: 'update',
+                        resourceType: 'ALIYUN_APIGW',
+                        changes: { after: desiredDefinition },
+                        drifted: true,
+                    };
+                }
+            }
+            catch {
+                // Ignore errors when checking remote
+            }
+            return {
+                logicalId,
+                action: 'create',
+                resourceType: 'ALIYUN_APIGW',
+                changes: { after: desiredDefinition },
+            };
+        }
+        // State exists, check for changes
+        try {
+            const groupInstance = currentState.instances.find((i) => i.type === 'ALIYUN_APIGW_GROUP');
+            if (groupInstance) {
+                const remoteGroup = await client.apigw.getApiGroup(groupInstance.id);
+                if (!remoteGroup) {
+                    // Resource in state but not remotely - needs recreate
+                    return {
+                        logicalId,
+                        action: 'create',
+                        resourceType: 'ALIYUN_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: 'ALIYUN_APIGW',
+                    changes: { before: currentDefinition, after: desiredDefinition },
+                };
+            }
+            return { logicalId, action: 'noop', resourceType: 'ALIYUN_APIGW' };
+        }
+        catch {
+            return {
+                logicalId,
+                action: 'create',
+                resourceType: 'ALIYUN_APIGW',
+                changes: { before: currentState.definition, after: desiredDefinition },
+            };
+        }
+    }));
+    // Find resources in state that are no longer in config
+    const allStates = (0, stateManager_1.getAllResources)(state);
+    const deletionItems = Object.entries(allStates)
+        .filter(([logicalId]) => logicalId.startsWith('events.') && !desiredLogicalIds.has(logicalId))
+        .map(([logicalId, resourceState]) => planEventDeletion(logicalId, resourceState.definition));
+    return { items: [...eventItems, ...deletionItems] };
+};
+exports.generateApigwPlan = generateApigwPlan;

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

@@ -0,0 +1,339 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteApigwResource = exports.updateApigwResource = exports.readApigwResourceByName = exports.readApigwResource = exports.createApigwResource = void 0;
+const aliyunClient_1 = require("../../common/aliyunClient");
+const apigwTypes_1 = require("./apigwTypes");
+const stateManager_1 = require("../../common/stateManager");
+const logger_1 = require("../../common/logger");
+const lang_1 = require("../../lang");
+const buildApigwGroupInstanceFromProvider = (info, region) => {
+    return {
+        type: 'ALIYUN_APIGW_GROUP',
+        arn: `arn:acs:apigateway:${region}:group/${info.groupId}`,
+        id: info.groupId ?? '',
+        groupId: info.groupId ?? null,
+        groupName: info.groupName ?? null,
+        description: info.description ?? null,
+        basePath: info.basePath ?? null,
+        subDomain: info.subDomain ?? null,
+        instanceId: info.instanceId ?? null,
+        instanceType: info.instanceType ?? null,
+        status: info.status ?? null,
+        createdTime: info.createdTime ?? null,
+        modifiedTime: info.modifiedTime ?? null,
+        billingStatus: info.billingStatus ?? null,
+        illegalStatus: info.illegalStatus ?? null,
+        trafficLimit: info.trafficLimit ?? null,
+    };
+};
+const buildApigwApiInstanceFromProvider = (info, region, groupId) => {
+    return {
+        type: 'ALIYUN_APIGW_API',
+        arn: `arn:acs:apigateway:${region}:group/${groupId}/api/${info.apiId}`,
+        id: info.apiId ?? '',
+        apiId: info.apiId ?? null,
+        apiName: info.apiName ?? null,
+        groupId: info.groupId ?? null,
+        groupName: info.groupName ?? null,
+        description: info.description ?? null,
+        visibility: info.visibility ?? null,
+        authType: info.authType ?? null,
+        requestConfig: info.requestConfig ?? null,
+        serviceConfig: info.serviceConfig ?? null,
+        resultType: info.resultType ?? null,
+        createdTime: info.createdTime ?? null,
+        modifiedTime: info.modifiedTime ?? null,
+    };
+};
+const buildApigwDeploymentInstance = (groupId, apiId, stageName, region) => {
+    return {
+        type: 'ALIYUN_APIGW_DEPLOYMENT',
+        arn: `arn:acs:apigateway:${region}:group/${groupId}/api/${apiId}/deployment/${stageName}`,
+        id: `${groupId}/${apiId}/${stageName}`,
+        groupId,
+        apiId,
+        stageName,
+    };
+};
+const createApigwResource = async (context, event, serviceName, roleArn, state) => {
+    const logicalId = `events.${event.key}`;
+    const client = (0, aliyunClient_1.createAliyunClient)(context);
+    const groupConfig = (0, apigwTypes_1.eventToApigwGroupConfig)(event, serviceName);
+    let groupId;
+    try {
+        const existingGroup = await client.apigw.findApiGroupByName(groupConfig.groupName);
+        if (existingGroup?.groupId) {
+            logger_1.logger.info(lang_1.lang.__('APIGW_GROUP_FOUND_REUSING', { groupName: groupConfig.groupName }));
+            groupId = existingGroup.groupId;
+        }
+        else {
+            groupId = await client.apigw.createApiGroup(groupConfig);
+        }
+    }
+    catch (error) {
+        logger_1.logger.debug(`Could not find existing group, creating new: ${error}`);
+        groupId = await client.apigw.createApiGroup(groupConfig);
+    }
+    // Get group info for state
+    const groupInfo = await client.apigw.getApiGroup(groupId);
+    if (!groupInfo) {
+        throw new Error(`Failed to get API group info after creation: ${groupId}`);
+    }
+    const instances = [
+        buildApigwGroupInstanceFromProvider(groupInfo, context.region),
+    ];
+    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: event.domain
+                ? {
+                    domainName: event.domain.domain_name,
+                    certificateName: event.domain.certificate_name,
+                }
+                : null,
+        },
+        instances,
+        lastUpdated: new Date().toISOString(),
+    };
+    state = (0, stateManager_1.setResource)(state, logicalId, partialResourceState);
+    // Create APIs and deployments for each trigger
+    for (const trigger of event.triggers) {
+        const apiConfig = (0, apigwTypes_1.triggerToApigwApiConfig)(event, trigger, groupId, serviceName, context.region, roleArn);
+        const apiId = await client.apigw.createApi(apiConfig);
+        // Get API info for state
+        const apiInfo = await client.apigw.getApi(groupId, apiId);
+        if (apiInfo) {
+            instances.push(buildApigwApiInstanceFromProvider(apiInfo, context.region, groupId));
+        }
+        // Deploy API to RELEASE stage
+        const deploymentConfig = {
+            groupId,
+            apiId,
+            stageName: 'RELEASE',
+            description: `${serviceName} API deployment for ${trigger.method} ${trigger.path}`,
+        };
+        await client.apigw.deployApi(deploymentConfig);
+        instances.push(buildApigwDeploymentInstance(groupId, apiId, 'RELEASE', context.region));
+        const updatedResourceState = {
+            mode: 'managed',
+            region: context.region,
+            definition: {
+                ...groupDefinition,
+                triggers: event.triggers.map((t) => ({
+                    method: t.method,
+                    path: t.path,
+                    backend: t.backend,
+                })),
+                domain: event.domain
+                    ? {
+                        domainName: event.domain.domain_name,
+                        certificateName: event.domain.certificate_name,
+                    }
+                    : null,
+            },
+            instances,
+            lastUpdated: new Date().toISOString(),
+        };
+        state = (0, stateManager_1.setResource)(state, logicalId, updatedResourceState);
+    }
+    if (event.domain) {
+        try {
+            state = await client.apigw.bindCustomDomain({
+                groupId,
+                domainName: event.domain.domain_name,
+                certificateName: event.domain.certificate_name,
+                certificateBody: event.domain.certificate_body,
+                certificatePrivateKey: event.domain.certificate_private_key,
+            }, state, logicalId);
+        }
+        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;
+        }
+    }
+    // Update final state with all instances (group + APIs + deployments)
+    const finalResourceState = {
+        mode: 'managed',
+        region: context.region,
+        definition: {
+            ...groupDefinition,
+            triggers: event.triggers.map((t) => ({
+                method: t.method,
+                path: t.path,
+                backend: t.backend,
+            })),
+            domain: event.domain
+                ? {
+                    domainName: event.domain.domain_name,
+                    certificateName: event.domain.certificate_name,
+                }
+                : null,
+        },
+        instances,
+        lastUpdated: new Date().toISOString(),
+    };
+    return (0, stateManager_1.setResource)(state, logicalId, finalResourceState);
+};
+exports.createApigwResource = createApigwResource;
+const readApigwResource = async (context, groupId) => {
+    const client = (0, aliyunClient_1.createAliyunClient)(context);
+    return await client.apigw.getApiGroup(groupId);
+};
+exports.readApigwResource = readApigwResource;
+const readApigwResourceByName = async (context, groupName) => {
+    const client = (0, aliyunClient_1.createAliyunClient)(context);
+    return await client.apigw.findApiGroupByName(groupName);
+};
+exports.readApigwResourceByName = readApigwResourceByName;
+const updateApigwResource = async (context, event, serviceName, roleArn, state) => {
+    const logicalId = `events.${event.key}`;
+    const existingState = (0, stateManager_1.getResource)(state, logicalId);
+    const client = (0, aliyunClient_1.createAliyunClient)(context);
+    if (!existingState) {
+        return (0, exports.createApigwResource)(context, event, serviceName, roleArn, state);
+    }
+    const existingInstances = existingState.instances;
+    const groupInstance = existingInstances.find((i) => i.type === 'ALIYUN_APIGW_GROUP');
+    if (!groupInstance) {
+        return (0, exports.createApigwResource)(context, event, serviceName, roleArn, state);
+    }
+    const groupId = groupInstance.id;
+    const groupConfig = (0, apigwTypes_1.eventToApigwGroupConfig)(event, serviceName);
+    await client.apigw.updateApiGroup(groupId, groupConfig);
+    const groupInfo = await client.apigw.getApiGroup(groupId);
+    if (!groupInfo) {
+        throw new Error(`Failed to get API group info after update: ${groupId}`);
+    }
+    const instances = [
+        buildApigwGroupInstanceFromProvider(groupInfo, context.region),
+    ];
+    const existingApis = existingInstances.filter((i) => i.type === 'ALIYUN_APIGW_API');
+    const neededApiKeys = new Set();
+    for (const trigger of event.triggers) {
+        const apiConfig = (0, apigwTypes_1.triggerToApigwApiConfig)(event, trigger, groupId, serviceName, context.region, roleArn);
+        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(groupId, apiId);
+        if (apiInfo) {
+            instances.push(buildApigwApiInstanceFromProvider(apiInfo, context.region, groupId));
+        }
+        const deploymentConfig = {
+            groupId,
+            apiId,
+            stageName: 'RELEASE',
+            description: `${serviceName} API deployment for ${trigger.method} ${trigger.path}`,
+        };
+        await client.apigw.deployApi(deploymentConfig);
+        instances.push(buildApigwDeploymentInstance(groupId, apiId, 'RELEASE', context.region));
+    }
+    for (const existingApi of existingApis) {
+        const apiInfo = await client.apigw.getApi(groupId, existingApi.id);
+        if (apiInfo) {
+            const isNeeded = event.triggers.some((t) => {
+                const expectedName = (0, apigwTypes_1.triggerToApigwApiConfig)(event, t, groupId, serviceName, context.region, roleArn).apiName;
+                return apiInfo.apiName === expectedName;
+            });
+            if (!isNeeded) {
+                try {
+                    await client.apigw.abolishApi(groupId, existingApi.id, 'RELEASE');
+                }
+                catch {
+                    // API might not be deployed
+                }
+                await client.apigw.deleteApi(groupId, existingApi.id);
+            }
+        }
+    }
+    if (event.domain) {
+        state = await client.apigw.bindCustomDomain({
+            groupId,
+            domainName: event.domain.domain_name,
+            certificateName: event.domain.certificate_name,
+            certificateBody: event.domain.certificate_body,
+            certificatePrivateKey: event.domain.certificate_private_key,
+        }, state, logicalId);
+    }
+    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: event.domain
+                ? {
+                    domainName: event.domain.domain_name,
+                    certificateName: event.domain.certificate_name,
+                }
+                : null,
+        },
+        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, aliyunClient_1.createAliyunClient)(context);
+    if (!existingState) {
+        return state;
+    }
+    const existingInstances = existingState.instances;
+    const groupInstance = existingInstances.find((i) => i.type === 'ALIYUN_APIGW_GROUP');
+    if (!groupInstance) {
+        return (0, stateManager_1.removeResource)(state, logicalId);
+    }
+    const groupId = groupInstance.id;
+    const deployments = existingInstances.filter((i) => i.type === 'ALIYUN_APIGW_DEPLOYMENT');
+    for (const deployment of deployments) {
+        try {
+            await client.apigw.abolishApi(deployment.groupId || groupId, deployment.apiId, deployment.stageName || 'RELEASE');
+        }
+        catch {
+            // Deployment might already be abolished
+        }
+    }
+    const apis = existingInstances.filter((i) => i.type === 'ALIYUN_APIGW_API');
+    for (const api of apis) {
+        try {
+            await client.apigw.deleteApi(groupId, api.id);
+        }
+        catch {
+            // API might already be deleted
+        }
+    }
+    try {
+        await client.apigw.deleteApiGroup(groupId);
+    }
+    catch {
+        // Group might already be deleted
+    }
+    return (0, stateManager_1.removeResource)(state, logicalId);
+};
+exports.deleteApigwResource = deleteApigwResource;

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

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractApigwDeploymentDefinition = exports.extractApigwApiDefinition = exports.extractApigwGroupDefinition = exports.triggerToApigwApiConfig = exports.generateApiKey = exports.eventToApigwGroupConfig = void 0;
+const common_1 = require("../../common");
+/**
+ * Convert EventDomain to API Gateway group config
+ */
+const eventToApigwGroupConfig = (event, serviceName) => {
+    return {
+        groupName: `${serviceName}-agw-group`.replace(/_/g, '-'),
+        description: `API Gateway group for ${serviceName}`,
+    };
+};
+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) => {
+    // Replace slashes with double underscores to preserve path structure
+    // Replace other non-alphanumeric chars with single underscore
+    const sanitizedPath = path
+        .replace(/\//g, '__')
+        .replace(/[^a-zA-Z0-9_]/g, '_')
+        .replace(/^__/, '') // Remove leading double underscore
+        .replace(/__$/, ''); // Remove trailing double underscore
+    return `${method}_${sanitizedPath}`;
+};
+exports.generateApiKey = generateApiKey;
+/**
+ * Resolves a function reference like ${functions.xxx} to the actual function name
+ */
+const resolveFunctionReference = (backendRef) => {
+    // Get IAC from context
+    const context = (0, common_1.getContext)();
+    if (!context.iac) {
+        common_1.logger.warn(`Cannot resolve function reference ${backendRef}: IAC not available in context`);
+        return backendRef;
+    }
+    // Use getIacDefinition to resolve function references
+    const functionDef = (0, common_1.getIacDefinition)(context.iac, backendRef);
+    if (!functionDef) {
+        // Not a function reference or function not found, return as is
+        common_1.logger.warn(`Function reference ${backendRef} could not be resolved from IAC`);
+        return backendRef;
+    }
+    const functionName = functionDef.name;
+    common_1.logger.info(`Resolved function reference ${backendRef} to function name: ${functionName}`);
+    return functionName;
+};
+/**
+ * Convert EventDomain trigger to API Gateway API config
+ */
+const triggerToApigwApiConfig = (event, trigger, groupId, serviceName, region, roleArn) => {
+    const method = trigger.method;
+    const path = trigger.path;
+    const backend = trigger.backend;
+    const resolvedFunctionName = resolveFunctionReference(backend);
+    const apiKey = (0, exports.generateApiKey)(method, path);
+    return {
+        groupId,
+        apiName: `${event.name}-agw-api-${apiKey}`.replace(/_/g, '-'),
+        visibility: 'PRIVATE',
+        authType: 'ANONYMOUS',
+        requestConfig: {
+            requestProtocol: 'HTTP',
+            requestHttpMethod: method,
+            requestPath: path,
+            requestMode: 'PASSTHROUGH',
+        },
+        serviceConfig: {
+            serviceProtocol: 'FunctionCompute',
+            functionComputeConfig: {
+                fcRegionId: region,
+                functionName: resolvedFunctionName,
+                roleArn,
+                fcVersion: '3.0',
+                method,
+            },
+        },
+        resultType: 'PASSTHROUGH',
+        resultSample: 'ServerlessInsight resultSample',
+    };
+};
+exports.triggerToApigwApiConfig = triggerToApigwApiConfig;
+/**
+ * Extract definition from API Gateway group config for state comparison
+ */
+const extractApigwGroupDefinition = (config) => {
+    return {
+        groupName: config.groupName,
+        description: config.description ?? null,
+        basePath: config.basePath ?? null,
+    };
+};
+exports.extractApigwGroupDefinition = extractApigwGroupDefinition;
+/**
+ * Extract definition from API Gateway API config for state comparison
+ */
+const extractApigwApiDefinition = (config) => {
+    return {
+        apiName: config.apiName,
+        groupId: config.groupId,
+        visibility: config.visibility,
+        authType: config.authType,
+        requestConfig: config.requestConfig,
+        serviceConfig: {
+            serviceProtocol: config.serviceConfig.serviceProtocol,
+            functionComputeConfig: config.serviceConfig.functionComputeConfig ?? null,
+        },
+        resultType: config.resultType ?? null,
+    };
+};
+exports.extractApigwApiDefinition = extractApigwApiDefinition;
+/**
+ * Extract definition from deployment config for state comparison
+ */
+const extractApigwDeploymentDefinition = (config) => {
+    return {
+        groupId: config.groupId,
+        apiId: config.apiId,
+        stageName: config.stageName,
+    };
+};
+exports.extractApigwDeploymentDefinition = extractApigwDeploymentDefinition;