@geek-fun/serverlessinsight 0.6.14 → 0.7.0

package/dist/src/common/volcengineClient/apigwOperations.js

@@ -0,0 +1,271 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createApigwOperations = void 0;
+const logger_1 = require("../logger");
+const lang_1 = require("../../lang");
+const createApigwOperations = (client) => {
+    if (!client) {
+        return {
+            createGateway: async (_config) => {
+                throw new Error(lang_1.lang.__('VOLCENGINE_APIGW_CLIENT_NOT_INITIALIZED'));
+            },
+            getGateway: async (_gatewayId) => {
+                throw new Error(lang_1.lang.__('VOLCENGINE_APIGW_CLIENT_NOT_INITIALIZED'));
+            },
+            findGatewayByName: async (_gatewayName) => {
+                throw new Error(lang_1.lang.__('VOLCENGINE_APIGW_CLIENT_NOT_INITIALIZED'));
+            },
+            updateGateway: async (_gatewayId, _config) => {
+                throw new Error(lang_1.lang.__('VOLCENGINE_APIGW_CLIENT_NOT_INITIALIZED'));
+            },
+            deleteGateway: async (_gatewayId) => {
+                throw new Error(lang_1.lang.__('VOLCENGINE_APIGW_CLIENT_NOT_INITIALIZED'));
+            },
+            createApi: async (_config) => {
+                throw new Error(lang_1.lang.__('VOLCENGINE_APIGW_CLIENT_NOT_INITIALIZED'));
+            },
+            getApi: async (_gatewayId, _apiId) => {
+                throw new Error(lang_1.lang.__('VOLCENGINE_APIGW_CLIENT_NOT_INITIALIZED'));
+            },
+            updateApi: async (_apiId, _config) => {
+                throw new Error(lang_1.lang.__('VOLCENGINE_APIGW_CLIENT_NOT_INITIALIZED'));
+            },
+            deleteApi: async (_gatewayId, _apiId) => {
+                throw new Error(lang_1.lang.__('VOLCENGINE_APIGW_CLIENT_NOT_INITIALIZED'));
+            },
+            deployApi: async (_gatewayId, _apiId) => {
+                throw new Error(lang_1.lang.__('VOLCENGINE_APIGW_CLIENT_NOT_INITIALIZED'));
+            },
+            bindDomain: async (_config) => {
+                throw new Error(lang_1.lang.__('VOLCENGINE_APIGW_CLIENT_NOT_INITIALIZED'));
+            },
+            unbindDomain: async (_gatewayId, _domainName) => {
+                throw new Error(lang_1.lang.__('VOLCENGINE_APIGW_CLIENT_NOT_INITIALIZED'));
+            },
+        };
+    }
+    return {
+        createGateway: async (config) => {
+            logger_1.logger.info(lang_1.lang.__('VOLCENGINE_CREATING_APIGW', { gatewayName: config.groupName }));
+            const params = {
+                Name: config.groupName,
+                ...(config.description && { Description: config.description }),
+                ...(config.protocol && { Protocol: config.protocol }),
+            };
+            const response = await client.fetchOpenAPI({
+                Action: 'CreateGateway',
+                Version: '2021-03-03',
+                method: 'POST',
+                headers: { 'content-type': 'application/json' },
+                data: params,
+            });
+            const data = (response.Result || {});
+            return {
+                gatewayId: data.GatewayId,
+                gatewayName: data.Name,
+                protocol: data.Protocol,
+                status: data.Status,
+                createdTime: data.CreatedTime,
+                description: data.Description,
+                subDomain: data.SubDomain,
+            };
+        },
+        getGateway: async (gatewayId) => {
+            try {
+                const response = await client.fetchOpenAPI({
+                    Action: 'GetGateway',
+                    Version: '2021-03-03',
+                    method: 'POST',
+                    headers: { 'content-type': 'application/json' },
+                    data: { GatewayId: gatewayId },
+                });
+                const data = (response.Result || {});
+                return {
+                    gatewayId: data.GatewayId,
+                    gatewayName: data.Name,
+                    protocol: data.Protocol,
+                    status: data.Status,
+                    createdTime: data.CreatedTime,
+                    description: data.Description,
+                    subDomain: data.SubDomain,
+                };
+            }
+            catch (error) {
+                if (error && typeof error === 'object' && 'code' in error) {
+                    if (error.code === 'ResourceNotFound' || error.code === 'GatewayNotFound') {
+                        return null;
+                    }
+                }
+                throw error;
+            }
+        },
+        findGatewayByName: async (gatewayName) => {
+            const response = await client.fetchOpenAPI({
+                Action: 'ListGateways',
+                Version: '2021-03-03',
+                method: 'POST',
+                headers: { 'content-type': 'application/json' },
+                data: { Name: gatewayName },
+            });
+            const result = (response.Result || {});
+            const gateways = (result.Gateways || []);
+            const gateway = gateways.find((g) => g.Name === gatewayName);
+            if (!gateway)
+                return null;
+            return {
+                gatewayId: gateway.GatewayId,
+                gatewayName: gateway.Name,
+                protocol: gateway.Protocol,
+                status: gateway.Status,
+                createdTime: gateway.CreatedTime,
+                description: gateway.Description,
+                subDomain: gateway.SubDomain,
+            };
+        },
+        updateGateway: async (gatewayId, config) => {
+            const params = {
+                GatewayId: gatewayId,
+                Name: config.groupName,
+                ...(config.description && { Description: config.description }),
+                ...(config.protocol && { Protocol: config.protocol }),
+            };
+            await client.fetchOpenAPI({
+                Action: 'UpdateGateway',
+                Version: '2021-03-03',
+                method: 'POST',
+                headers: { 'content-type': 'application/json' },
+                data: params,
+            });
+        },
+        deleteGateway: async (gatewayId) => {
+            logger_1.logger.info(lang_1.lang.__('VOLCENGINE_DELETING_APIGW', { gatewayName: gatewayId }));
+            await client.fetchOpenAPI({
+                Action: 'DeleteGateway',
+                Version: '2021-03-03',
+                method: 'POST',
+                headers: { 'content-type': 'application/json' },
+                data: { GatewayId: gatewayId },
+            });
+        },
+        createApi: async (config) => {
+            const params = {
+                GatewayId: config.gatewayId,
+                Name: config.apiName,
+                Method: config.method,
+                Path: config.path,
+                BackendType: 'Function',
+                BackendConfig: {
+                    FunctionName: config.backendFunctionName,
+                    Timeout: config.requestTimeout ?? 60,
+                },
+            };
+            const response = await client.fetchOpenAPI({
+                Action: 'CreateApi',
+                Version: '2021-03-03',
+                method: 'POST',
+                headers: { 'content-type': 'application/json' },
+                data: params,
+            });
+            const data = (response.Result || {});
+            return data.ApiId;
+        },
+        getApi: async (gatewayId, apiId) => {
+            try {
+                const response = await client.fetchOpenAPI({
+                    Action: 'GetApi',
+                    Version: '2021-03-03',
+                    method: 'POST',
+                    headers: { 'content-type': 'application/json' },
+                    data: { GatewayId: gatewayId, ApiId: apiId },
+                });
+                const data = (response.Result || {});
+                const backendConfig = (data.BackendConfig || {});
+                return {
+                    apiId: data.ApiId,
+                    apiName: data.Name,
+                    gatewayId: data.GatewayId,
+                    method: data.Method,
+                    path: data.Path,
+                    description: data.Description,
+                    backendType: data.BackendType,
+                    backendId: data.BackendId,
+                    backendFunctionName: backendConfig.FunctionName,
+                    status: data.Status,
+                    createdTime: data.CreatedTime,
+                };
+            }
+            catch (error) {
+                if (error && typeof error === 'object' && 'code' in error) {
+                    if (error.code === 'ResourceNotFound' || error.code === 'ApiNotFound') {
+                        return null;
+                    }
+                }
+                throw error;
+            }
+        },
+        updateApi: async (apiId, config) => {
+            const params = {
+                ApiId: apiId,
+                GatewayId: config.gatewayId,
+                Name: config.apiName,
+                Method: config.method,
+                Path: config.path,
+                BackendType: 'Function',
+                BackendConfig: {
+                    FunctionName: config.backendFunctionName,
+                    Timeout: config.requestTimeout ?? 60,
+                },
+            };
+            await client.fetchOpenAPI({
+                Action: 'UpdateApi',
+                Version: '2021-03-03',
+                method: 'POST',
+                headers: { 'content-type': 'application/json' },
+                data: params,
+            });
+        },
+        deleteApi: async (gatewayId, apiId) => {
+            await client.fetchOpenAPI({
+                Action: 'DeleteApi',
+                Version: '2021-03-03',
+                method: 'POST',
+                headers: { 'content-type': 'application/json' },
+                data: { GatewayId: gatewayId, ApiId: apiId },
+            });
+        },
+        deployApi: async (gatewayId, apiId) => {
+            await client.fetchOpenAPI({
+                Action: 'DeployApi',
+                Version: '2021-03-03',
+                method: 'POST',
+                headers: { 'content-type': 'application/json' },
+                data: { GatewayId: gatewayId, ApiId: apiId, Stage: 'RELEASE' },
+            });
+        },
+        bindDomain: async (config) => {
+            const params = {
+                GatewayId: config.gatewayId,
+                DomainName: config.domainName,
+                ...(config.certificateId && { CertificateId: config.certificateId }),
+            };
+            await client.fetchOpenAPI({
+                Action: 'BindDomain',
+                Version: '2021-03-03',
+                method: 'POST',
+                headers: { 'content-type': 'application/json' },
+                data: params,
+            });
+            logger_1.logger.info(lang_1.lang.__('APIGW_DOMAIN_BOUND_SUCCESS', { domain: config.domainName }));
+        },
+        unbindDomain: async (gatewayId, domainName) => {
+            await client.fetchOpenAPI({
+                Action: 'UnbindDomain',
+                Version: '2021-03-03',
+                method: 'POST',
+                headers: { 'content-type': 'application/json' },
+                data: { GatewayId: gatewayId, DomainName: domainName },
+            });
+        },
+    };
+};
+exports.createApigwOperations = createApigwOperations;

package/dist/src/common/volcengineClient/iamOperations.js

@@ -0,0 +1,349 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createIamOperations = void 0;
+const logger_1 = require("../logger");
+const lang_1 = require("../../lang");
+const DEFAULT_TRUST_POLICY_SERVICES = ['vefaas.volcengine.com'];
+const buildTrustPolicyDocument = (trustedServices) => {
+    return JSON.stringify({
+        Statement: [
+            {
+                Effect: 'Allow',
+                Action: ['sts:AssumeRole'],
+                Principal: {
+                    Service: trustedServices,
+                },
+            },
+        ],
+    });
+};
+const VEFAAS_EXECUTION_POLICY = JSON.stringify({
+    Statement: [
+        {
+            Effect: 'Allow',
+            Action: ['vefaas:*'],
+            Resource: '*',
+        },
+        {
+            Effect: 'Allow',
+            Action: ['tos:GetObject', 'tos:PutObject', 'tos:DeleteObject', 'tos:ListBucket'],
+            Resource: '*',
+        },
+        {
+            Effect: 'Allow',
+            Action: ['vpc:DescribeVpcs', 'vpc:DescribeSubnets', 'vpc:DescribeSecurityGroups'],
+            Resource: '*',
+        },
+        {
+            Effect: 'Allow',
+            Action: ['tls:CreateProject', 'tls:CreateTopic', 'tls:PutLogs'],
+            Resource: '*',
+        },
+    ],
+});
+const createIamOperations = (iamClient) => {
+    const createAndAttachPolicy = async (roleName) => {
+        const policyName = `${roleName}-policy`;
+        try {
+            await iamClient.fetchOpenAPI({
+                Action: 'CreatePolicy',
+                Version: '2024-01-01',
+                method: 'POST',
+                headers: { 'content-type': 'application/json' },
+                data: {
+                    PolicyName: policyName,
+                    PolicyDocument: VEFAAS_EXECUTION_POLICY,
+                    Description: `veFaaS execution policy for ${roleName}`,
+                },
+            });
+        }
+        catch (error) {
+            if (error && typeof error === 'object' && 'code' in error) {
+                if (error.code === 'PolicyAlreadyExists' || error.code === 'Conflict') {
+                    logger_1.logger.info(lang_1.lang.__('IAM_POLICY_ALREADY_EXISTS', { policyName }));
+                }
+                else {
+                    throw error;
+                }
+            }
+            else {
+                throw error;
+            }
+        }
+        try {
+            await iamClient.fetchOpenAPI({
+                Action: 'AttachRolePolicy',
+                Version: '2024-01-01',
+                method: 'POST',
+                headers: { 'content-type': 'application/json' },
+                data: {
+                    RoleName: roleName,
+                    PolicyName: policyName,
+                    PolicyType: 'Custom',
+                },
+            });
+        }
+        catch (error) {
+            if (error && typeof error === 'object' && 'code' in error) {
+                if (error.code === 'PolicyAlreadyAttached' || error.code === 'Conflict') {
+                    logger_1.logger.info(lang_1.lang.__('IAM_POLICY_ALREADY_ATTACHED', { policyName, roleName }));
+                }
+                else {
+                    throw error;
+                }
+            }
+            else {
+                throw error;
+            }
+        }
+        return policyName;
+    };
+    const detachAndDeletePolicy = async (roleName) => {
+        const policyName = `${roleName}-policy`;
+        try {
+            await iamClient.fetchOpenAPI({
+                Action: 'DetachRolePolicy',
+                Version: '2024-01-01',
+                method: 'POST',
+                headers: { 'content-type': 'application/json' },
+                data: {
+                    RoleName: roleName,
+                    PolicyName: policyName,
+                    PolicyType: 'Custom',
+                },
+            });
+        }
+        catch {
+            // Ignore if policy is not attached
+        }
+        try {
+            await iamClient.fetchOpenAPI({
+                Action: 'DeletePolicy',
+                Version: '2024-01-01',
+                method: 'POST',
+                headers: { 'content-type': 'application/json' },
+                data: {
+                    PolicyName: policyName,
+                    PolicyType: 'Custom',
+                },
+            });
+        }
+        catch {
+            // Ignore if policy doesn't exist
+        }
+    };
+    return {
+        createRole: async (config) => {
+            const roleName = config.roleName;
+            const trustedServices = config.trustPolicy.Statement[0]?.Principal.Service || DEFAULT_TRUST_POLICY_SERVICES;
+            const trustPolicyDocument = buildTrustPolicyDocument(trustedServices);
+            try {
+                const response = await iamClient.fetchOpenAPI({
+                    Action: 'CreateRole',
+                    Version: '2024-01-01',
+                    method: 'POST',
+                    headers: { 'content-type': 'application/json' },
+                    data: {
+                        RoleName: roleName,
+                        TrustPolicyDocument: trustPolicyDocument,
+                        DisplayName: config.displayName,
+                        Description: config.description ?? `ServerlessInsight veFaaS execution role for ${roleName}`,
+                        MaxSessionDuration: config.maxSessionDuration ?? 3600,
+                    },
+                });
+                const data = (response.Result || {});
+                const roleData = (data.Role || {});
+                const policyName = await createAndAttachPolicy(roleName);
+                logger_1.logger.info(lang_1.lang.__('IAM_ROLE_CREATED', { roleName }));
+                return {
+                    roleName: roleData.RoleName,
+                    roleId: roleData.RoleId,
+                    trn: roleData.TRN,
+                    description: roleData.Description,
+                    createdTime: roleData.CreateTime,
+                    maxSessionDuration: roleData.MaxSessionDuration,
+                    trustPolicyDocument,
+                    policyName,
+                };
+            }
+            catch (error) {
+                if (error && typeof error === 'object' && 'code' in error) {
+                    if (error.code === 'RoleAlreadyExists' || error.code === 'Conflict') {
+                        logger_1.logger.info(lang_1.lang.__('IAM_ROLE_ALREADY_EXISTS', { roleName }));
+                        try {
+                            const existingRole = await iamClient.fetchOpenAPI({
+                                Action: 'GetRole',
+                                Version: '2024-01-01',
+                                method: 'POST',
+                                headers: { 'content-type': 'application/json' },
+                                data: { RoleName: roleName },
+                            });
+                            await iamClient.fetchOpenAPI({
+                                Action: 'UpdateTrustPolicy',
+                                Version: '2024-01-01',
+                                method: 'POST',
+                                headers: { 'content-type': 'application/json' },
+                                data: {
+                                    RoleName: roleName,
+                                    TrustPolicyDocument: trustPolicyDocument,
+                                },
+                            });
+                            const policyName = await createAndAttachPolicy(roleName);
+                            const roleData = (existingRole.Result || {})
+                                .Role;
+                            return {
+                                roleName: roleData?.RoleName,
+                                roleId: roleData?.RoleId,
+                                trn: roleData?.TRN,
+                                description: roleData?.Description,
+                                createdTime: roleData?.CreateTime,
+                                maxSessionDuration: roleData?.MaxSessionDuration,
+                                trustPolicyDocument,
+                                policyName,
+                            };
+                        }
+                        catch (recoveryError) {
+                            // eslint-disable-next-line preserve-caught-error
+                            throw new Error(lang_1.lang.__('IAM_ROLE_DRIFT_RECOVERY_FAILED', {
+                                roleName,
+                                error: recoveryError instanceof Error ? recoveryError.message : String(recoveryError),
+                            }));
+                        }
+                    }
+                }
+                throw error;
+            }
+        },
+        getRole: async (roleName) => {
+            try {
+                const response = await iamClient.fetchOpenAPI({
+                    Action: 'GetRole',
+                    Version: '2024-01-01',
+                    method: 'POST',
+                    headers: { 'content-type': 'application/json' },
+                    data: { RoleName: roleName },
+                });
+                const roleData = (response.Result || {}).Role;
+                if (!roleData) {
+                    return null;
+                }
+                return {
+                    roleName: roleData.RoleName,
+                    roleId: roleData.RoleId,
+                    trn: roleData.TRN,
+                    description: roleData.Description,
+                    createdTime: roleData.CreateTime,
+                    maxSessionDuration: roleData.MaxSessionDuration,
+                    trustPolicyDocument: roleData.TrustPolicyDocument,
+                    policyName: `${roleName}-policy`,
+                };
+            }
+            catch (error) {
+                if (error && typeof error === 'object' && 'code' in error) {
+                    if (error.code === 'RoleNotFound' || error.code === 'NoSuchEntity') {
+                        return null;
+                    }
+                }
+                throw error;
+            }
+        },
+        updateRoleTrustPolicy: async (roleName, trustPolicy) => {
+            const trustPolicyDocument = JSON.stringify(trustPolicy);
+            try {
+                await iamClient.fetchOpenAPI({
+                    Action: 'UpdateTrustPolicy',
+                    Version: '2024-01-01',
+                    method: 'POST',
+                    headers: { 'content-type': 'application/json' },
+                    data: {
+                        RoleName: roleName,
+                        TrustPolicyDocument: trustPolicyDocument,
+                    },
+                });
+                logger_1.logger.info(lang_1.lang.__('IAM_ROLE_TRUST_POLICY_UPDATED', { roleName }));
+            }
+            catch (error) {
+                if (error && typeof error === 'object' && 'code' in error) {
+                    if (error.code === 'RoleNotFound' || error.code === 'NoSuchEntity') {
+                        // eslint-disable-next-line preserve-caught-error
+                        throw new Error(lang_1.lang.__('IAM_ROLE_NOT_FOUND_IN_CLOUD', { roleName }));
+                    }
+                }
+                throw error;
+            }
+        },
+        deleteRole: async (roleName) => {
+            await detachAndDeletePolicy(roleName);
+            try {
+                await iamClient.fetchOpenAPI({
+                    Action: 'DeleteRole',
+                    Version: '2024-01-01',
+                    method: 'POST',
+                    headers: { 'content-type': 'application/json' },
+                    data: { RoleName: roleName },
+                });
+                logger_1.logger.info(lang_1.lang.__('IAM_ROLE_DELETED', { roleName }));
+            }
+            catch (error) {
+                if (error && typeof error === 'object' && 'code' in error) {
+                    if (error.code === 'RoleNotFound' || error.code === 'NoSuchEntity') {
+                        logger_1.logger.warn(lang_1.lang.__('IAM_ROLE_NOT_FOUND_IN_CLOUD', { roleName }));
+                        return;
+                    }
+                }
+                throw error;
+            }
+        },
+        attachRolePolicy: async (roleName, policyName, policyType) => {
+            try {
+                await iamClient.fetchOpenAPI({
+                    Action: 'AttachRolePolicy',
+                    Version: '2024-01-01',
+                    method: 'POST',
+                    headers: { 'content-type': 'application/json' },
+                    data: {
+                        RoleName: roleName,
+                        PolicyName: policyName,
+                        PolicyType: policyType,
+                    },
+                });
+                logger_1.logger.info(lang_1.lang.__('IAM_POLICY_ATTACHED', { policyName, roleName }));
+            }
+            catch (error) {
+                if (error && typeof error === 'object' && 'code' in error) {
+                    if (error.code === 'PolicyAlreadyAttached' || error.code === 'Conflict') {
+                        logger_1.logger.info(lang_1.lang.__('IAM_POLICY_ALREADY_ATTACHED', { policyName, roleName }));
+                        return;
+                    }
+                }
+                throw error;
+            }
+        },
+        detachRolePolicy: async (roleName, policyName) => {
+            try {
+                await iamClient.fetchOpenAPI({
+                    Action: 'DetachRolePolicy',
+                    Version: '2024-01-01',
+                    method: 'POST',
+                    headers: { 'content-type': 'application/json' },
+                    data: {
+                        RoleName: roleName,
+                        PolicyName: policyName,
+                        PolicyType: 'Custom',
+                    },
+                });
+                logger_1.logger.info(lang_1.lang.__('IAM_POLICY_DETACHED', { policyName, roleName }));
+            }
+            catch (error) {
+                if (error &&
+                    typeof error === 'object' &&
+                    'code' in error &&
+                    (error.code === 'PolicyNotAttached' || error.code === 'NoSuchEntity')) {
+                    return;
+                }
+                logger_1.logger.warn(lang_1.lang.__('IAM_POLICY_DETACH_FAILED', { policyName, roleName, error: String(error) }));
+            }
+        },
+    };
+};
+exports.createIamOperations = createIamOperations;