@geek-fun/serverlessinsight 0.4.0 → 0.5.0

package/dist/src/common/tencentClient/cosOperations.js

@@ -0,0 +1,287 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCosOperations = void 0;
+const createCosOperations = (cosClient) => ({
+    createBucket: async (config) => {
+        // Create bucket
+        await new Promise((resolve, reject) => {
+            cosClient.putBucket({
+                Bucket: config.Bucket,
+                Region: config.Region,
+            }, (err) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve();
+                }
+            });
+        });
+        // Set ACL if specified
+        if (config.ACL) {
+            await new Promise((resolve, reject) => {
+                cosClient.putBucketAcl({
+                    Bucket: config.Bucket,
+                    Region: config.Region,
+                    ACL: config.ACL,
+                }, (err) => {
+                    if (err) {
+                        reject(err);
+                    }
+                    else {
+                        resolve();
+                    }
+                });
+            });
+        }
+        // Set website configuration if specified
+        if (config.WebsiteConfiguration) {
+            const websiteConfig = config.WebsiteConfiguration;
+            await new Promise((resolve, reject) => {
+                cosClient.putBucketWebsite({
+                    Bucket: config.Bucket,
+                    Region: config.Region,
+                    WebsiteConfiguration: websiteConfig,
+                }, (err) => {
+                    if (err) {
+                        reject(err);
+                    }
+                    else {
+                        resolve();
+                    }
+                });
+            });
+        }
+    },
+    getBucket: async (bucketName, region) => {
+        try {
+            // Check if bucket exists
+            await new Promise((resolve, reject) => {
+                cosClient.headBucket({
+                    Bucket: bucketName,
+                    Region: region,
+                }, (err, data) => {
+                    if (err) {
+                        reject(err);
+                    }
+                    else {
+                        resolve(data);
+                    }
+                });
+            });
+            // Get ACL
+            let acl;
+            let accessControlPolicy;
+            try {
+                const aclResult = await new Promise((resolve, reject) => {
+                    cosClient.getBucketAcl({
+                        Bucket: bucketName,
+                        Region: region,
+                    }, (err, data) => {
+                        if (err) {
+                            reject(err);
+                        }
+                        else {
+                            resolve(data);
+                        }
+                    });
+                });
+                acl = aclResult.ACL;
+                accessControlPolicy = {
+                    owner: aclResult.Owner
+                        ? {
+                            id: aclResult.Owner.ID,
+                            displayName: undefined,
+                        }
+                        : undefined,
+                    grants: aclResult.Grants?.map((g) => ({
+                        grantee: g.Grantee
+                            ? {
+                                type: 'ID' in g.Grantee ? 'CanonicalUser' : 'Group',
+                                uri: 'URI' in g.Grantee ? g.Grantee.URI : undefined,
+                                id: 'ID' in g.Grantee ? g.Grantee.ID : undefined,
+                                displayName: undefined,
+                            }
+                            : undefined,
+                        permission: g.Permission,
+                    })),
+                };
+            }
+            catch {
+                // ACL might not be accessible due to insufficient permissions
+            }
+            // Get CORS configuration
+            let corsConfiguration;
+            try {
+                const corsResult = await new Promise((resolve, reject) => {
+                    cosClient.getBucketCors({
+                        Bucket: bucketName,
+                        Region: region,
+                    }, (err, data) => {
+                        if (err) {
+                            reject(err);
+                        }
+                        else {
+                            resolve(data);
+                        }
+                    });
+                });
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                corsConfiguration = corsResult.CORSRules?.map((r) => ({
+                    id: r.ID,
+                    allowedOrigins: r.AllowedOrigin,
+                    allowedMethods: r.AllowedMethod,
+                    allowedHeaders: r.AllowedHeader,
+                    exposeHeaders: r.ExposeHeader,
+                    maxAgeSeconds: r.MaxAgeSeconds,
+                }));
+            }
+            catch {
+                // CORS might not be configured
+            }
+            // Get website configuration
+            let websiteConfig;
+            try {
+                const websiteResult = await new Promise((resolve, reject) => {
+                    cosClient.getBucketWebsite({
+                        Bucket: bucketName,
+                        Region: region,
+                    }, (err, data) => {
+                        if (err) {
+                            reject(err);
+                        }
+                        else {
+                            resolve(data);
+                        }
+                    });
+                });
+                if (websiteResult.WebsiteConfiguration?.IndexDocument ||
+                    websiteResult.WebsiteConfiguration?.ErrorDocument) {
+                    websiteConfig = {
+                        IndexDocument: websiteResult.WebsiteConfiguration.IndexDocument,
+                        ErrorDocument: websiteResult.WebsiteConfiguration.ErrorDocument,
+                    };
+                }
+            }
+            catch {
+                // Website configuration might not be set
+            }
+            // Get versioning configuration
+            let versioningConfig;
+            try {
+                const versioningResult = await new Promise((resolve, reject) => {
+                    cosClient.getBucketVersioning({
+                        Bucket: bucketName,
+                        Region: region,
+                    }, (err, data) => {
+                        if (err) {
+                            reject(err);
+                        }
+                        else {
+                            resolve(data);
+                        }
+                    });
+                });
+                versioningConfig = {
+                    status: versioningResult.VersioningConfiguration?.Status,
+                };
+            }
+            catch {
+                // Versioning might not be accessible
+            }
+            // Get tagging configuration
+            let taggingConfig;
+            try {
+                const taggingResult = await new Promise((resolve, reject) => {
+                    cosClient.getBucketTagging({
+                        Bucket: bucketName,
+                        Region: region,
+                    }, (err, data) => {
+                        if (err) {
+                            reject(err);
+                        }
+                        else {
+                            resolve(data);
+                        }
+                    });
+                });
+                taggingConfig = {
+                    tags: taggingResult.Tags?.map((t) => ({
+                        key: t.Key,
+                        value: t.Value,
+                    })),
+                };
+            }
+            catch {
+                // Tagging might not be configured
+            }
+            return {
+                Name: bucketName,
+                Location: region,
+                ACL: acl,
+                WebsiteConfiguration: websiteConfig,
+                AccessControlPolicy: accessControlPolicy,
+                CorsConfiguration: corsConfiguration,
+                VersioningConfiguration: versioningConfig,
+                TaggingConfiguration: taggingConfig,
+            };
+        }
+        catch (error) {
+            if (error && typeof error === 'object' && 'statusCode' in error) {
+                const statusCode = error.statusCode;
+                if (statusCode === 404) {
+                    return null;
+                }
+            }
+            throw error;
+        }
+    },
+    updateBucketAcl: async (bucketName, region, acl) => {
+        await new Promise((resolve, reject) => {
+            cosClient.putBucketAcl({
+                Bucket: bucketName,
+                Region: region,
+                ACL: acl,
+            }, (err) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve();
+                }
+            });
+        });
+    },
+    updateBucketWebsite: async (bucketName, region, websiteConfig) => {
+        await new Promise((resolve, reject) => {
+            cosClient.putBucketWebsite({
+                Bucket: bucketName,
+                Region: region,
+                WebsiteConfiguration: websiteConfig,
+            }, (err) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve();
+                }
+            });
+        });
+    },
+    deleteBucket: async (bucketName, region) => {
+        await new Promise((resolve, reject) => {
+            cosClient.deleteBucket({
+                Bucket: bucketName,
+                Region: region,
+            }, (err) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve();
+                }
+            });
+        });
+    },
+});
+exports.createCosOperations = createCosOperations;

package/dist/src/common/tencentClient/esOperations.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTencentEsOperations = void 0;
+const types_1 = require("./types");
+const logger_1 = require("../logger");
+const lang_1 = require("../../lang");
+const waitForSpaceReady = async (getSpace, spaceId) => {
+    const maxAttempts = 60;
+    let attempts = 0;
+    while (attempts < maxAttempts) {
+        const space = await getSpace(spaceId);
+        if (!space) {
+            throw new Error(lang_1.lang.__('TENCENT_ES_SPACE_NOT_FOUND', { spaceId }));
+        }
+        if (space.Status === types_1.TencentEsSpaceStatus.NORMAL) {
+            logger_1.logger.info(lang_1.lang.__('TENCENT_ES_SPACE_READY', { spaceId }));
+            return;
+        }
+        if (space.Status === types_1.TencentEsSpaceStatus.DELETED ||
+            space.Status === types_1.TencentEsSpaceStatus.DELETING) {
+            throw new Error(lang_1.lang.__('TENCENT_ES_SPACE_ERROR_STATE', { status: String(space.Status) }));
+        }
+        logger_1.logger.info(lang_1.lang.__('TENCENT_ES_SPACE_WAITING', { spaceId, status: String(space.Status) }));
+        await new Promise((resolve) => setTimeout(resolve, 10000));
+        attempts++;
+    }
+    throw new Error(lang_1.lang.__('TENCENT_ES_SPACE_TIMEOUT_READY', { spaceId }));
+};
+const waitForSpaceDeleted = async (getSpace, spaceId) => {
+    const maxAttempts = 60;
+    let attempts = 0;
+    while (attempts < maxAttempts) {
+        const space = await getSpace(spaceId);
+        if (!space) {
+            logger_1.logger.info(lang_1.lang.__('TENCENT_ES_SPACE_DELETED', { spaceId }));
+            return;
+        }
+        if (space.Status === types_1.TencentEsSpaceStatus.DELETED) {
+            logger_1.logger.info(lang_1.lang.__('TENCENT_ES_SPACE_DELETED', { spaceId }));
+            return;
+        }
+        logger_1.logger.info(lang_1.lang.__('TENCENT_ES_SPACE_WAITING_DELETE', { spaceId }));
+        await new Promise((resolve) => setTimeout(resolve, 10000));
+        attempts++;
+    }
+    throw new Error(lang_1.lang.__('TENCENT_ES_SPACE_TIMEOUT_DELETE', { spaceId }));
+};
+const createTencentEsOperations = (esClient, _context) => {
+    const operations = {
+        createSpace: async (config) => {
+            const params = {
+                SpaceName: config.SpaceName,
+            };
+            if (config.VpcInfo && config.VpcInfo.length > 0) {
+                params.VpcInfo = config.VpcInfo;
+            }
+            if (config.Zone) {
+                params.Zone = config.Zone;
+            }
+            if (config.KibanaWhiteIpList && config.KibanaWhiteIpList.length > 0) {
+                params.KibanaWhiteIpList = config.KibanaWhiteIpList;
+            }
+            try {
+                const response = await esClient.CreateServerlessSpaceV2(params);
+                logger_1.logger.info(lang_1.lang.__('TENCENT_ES_SPACE_CREATION_INITIATED'));
+                if (!response.SpaceId) {
+                    throw new Error(lang_1.lang.__('TENCENT_ES_SPACE_NO_ID_RETURNED'));
+                }
+                const spaceId = response.SpaceId;
+                await waitForSpaceReady(operations.getSpace, spaceId);
+                return spaceId;
+            }
+            catch (error) {
+                logger_1.logger.error(lang_1.lang.__('TENCENT_ES_SPACE_CREATION_FAILED', { error: String(error) }));
+                throw error;
+            }
+        },
+        getSpace: async (spaceId) => {
+            const params = {
+                SpaceIds: [spaceId],
+            };
+            try {
+                const response = await esClient.DescribeServerlessSpaces(params);
+                if (!response.ServerlessSpaces || response.ServerlessSpaces.length === 0) {
+                    return null;
+                }
+                const space = response.ServerlessSpaces[0];
+                return {
+                    SpaceId: space.SpaceId || '',
+                    SpaceName: space.SpaceName || '',
+                    Status: space.Status ?? types_1.TencentEsSpaceStatus.CREATING,
+                    CreateTime: space.CreateTime,
+                    IndexCount: space.IndexCount,
+                    KibanaUrl: space.KibanaUrl,
+                    KibanaPrivateUrl: space.KibanaPrivateUrl,
+                };
+            }
+            catch (error) {
+                logger_1.logger.error(lang_1.lang.__('TENCENT_ES_SPACE_GET_FAILED', { error: String(error) }));
+                return null;
+            }
+        },
+        updateSpace: async (spaceId, config) => {
+            const params = {
+                SpaceId: spaceId,
+                SpaceName: config.SpaceName,
+            };
+            if (config.KibanaWhiteIpList && config.KibanaWhiteIpList.length > 0) {
+                params.KibanaWhiteIpList = config.KibanaWhiteIpList;
+            }
+            try {
+                await esClient.UpdateServerlessSpace(params);
+                logger_1.logger.info(lang_1.lang.__('TENCENT_ES_SPACE_UPDATED', { spaceId }));
+                await waitForSpaceReady(operations.getSpace, spaceId);
+            }
+            catch (error) {
+                logger_1.logger.error(lang_1.lang.__('TENCENT_ES_SPACE_UPDATE_FAILED', { error: String(error) }));
+                throw error;
+            }
+        },
+        deleteSpace: async (spaceId) => {
+            try {
+                // Delete all instances in the space first.
+                // Note: The Tencent Cloud ES SDK does not provide a DeleteServerlessSpace API.
+                // Deleting all instances within the space effectively decommissions it.
+                const instancesResponse = await esClient.DescribeServerlessInstances({
+                    SpaceIds: [spaceId],
+                });
+                if (instancesResponse.Instances && instancesResponse.Instances.length > 0) {
+                    for (const instance of instancesResponse.Instances) {
+                        if (instance.InstanceId) {
+                            await esClient.DeleteServerlessInstance({
+                                InstanceId: instance.InstanceId,
+                            });
+                        }
+                    }
+                }
+                logger_1.logger.info(lang_1.lang.__('TENCENT_ES_SPACE_DELETION_INITIATED', { spaceId }));
+                await waitForSpaceDeleted(operations.getSpace, spaceId);
+            }
+            catch (error) {
+                if (error &&
+                    typeof error === 'object' &&
+                    'code' in error &&
+                    (error.code === 'ResourceNotFound' || error.code === 'InvalidParameterValue')) {
+                    logger_1.logger.info(lang_1.lang.__('TENCENT_ES_SPACE_DELETED', { spaceId }));
+                    return;
+                }
+                logger_1.logger.error(lang_1.lang.__('TENCENT_ES_SPACE_DELETE_FAILED', { error: String(error) }));
+                throw error;
+            }
+        },
+    };
+    return operations;
+};
+exports.createTencentEsOperations = createTencentEsOperations;

package/dist/src/common/tencentClient/index.js

@@ -0,0 +1,116 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTencentClient = void 0;
+const tencentcloud = __importStar(require("tencentcloud-sdk-nodejs-scf"));
+const cynosdb = __importStar(require("tencentcloud-sdk-nodejs-cynosdb"));
+const tencentEs = __importStar(require("tencentcloud-sdk-nodejs-es"));
+const cos_nodejs_sdk_v5_1 = __importDefault(require("cos-nodejs-sdk-v5"));
+const scfOperations_1 = require("./scfOperations");
+const cosOperations_1 = require("./cosOperations");
+const tdsqlcOperations_1 = require("./tdsqlcOperations");
+const esOperations_1 = require("./esOperations");
+__exportStar(require("./types"), exports);
+const ScfClient = tencentcloud.scf.v20180416.Client;
+const CynosdbClient = cynosdb.cynosdb.v20190107.Client;
+const EsClient = tencentEs.es.v20180416.Client;
+// Initialize SDK clients (internal)
+const initializeSdkClients = (context) => {
+    const scfClientConfig = {
+        credential: {
+            secretId: context.accessKeyId,
+            secretKey: context.accessKeySecret,
+        },
+        region: context.region,
+        profile: {
+            httpProfile: {
+                endpoint: 'scf.tencentcloudapi.com',
+            },
+        },
+    };
+    const scfClient = new ScfClient(scfClientConfig);
+    const cosClient = new cos_nodejs_sdk_v5_1.default({
+        SecretId: context.accessKeyId,
+        SecretKey: context.accessKeySecret,
+    });
+    const cynosdbClientConfig = {
+        credential: {
+            secretId: context.accessKeyId,
+            secretKey: context.accessKeySecret,
+        },
+        region: context.region,
+        profile: {
+            httpProfile: {
+                endpoint: 'cynosdb.tencentcloudapi.com',
+            },
+        },
+    };
+    const cynosdbClient = new CynosdbClient(cynosdbClientConfig);
+    const esClientConfig = {
+        credential: {
+            secretId: context.accessKeyId,
+            secretKey: context.accessKeySecret,
+        },
+        region: context.region,
+        profile: {
+            httpProfile: {
+                endpoint: 'es.tencentcloudapi.com',
+            },
+        },
+    };
+    const esClient = new EsClient(esClientConfig);
+    return {
+        scf: scfClient,
+        cos: cosClient,
+        cynosdb: cynosdbClient,
+        es: esClient,
+    };
+};
+const createTencentClient = (context) => {
+    const sdkClients = initializeSdkClients(context);
+    return {
+        scf: (0, scfOperations_1.createScfOperations)(sdkClients.scf),
+        cos: (0, cosOperations_1.createCosOperations)(sdkClients.cos),
+        tdsqlc: (0, tdsqlcOperations_1.createTdsqlcOperations)(sdkClients.cynosdb, context),
+        es: (0, esOperations_1.createTencentEsOperations)(sdkClients.es, context),
+    };
+};
+exports.createTencentClient = createTencentClient;

package/dist/src/common/tencentClient/scfOperations.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createScfOperations = void 0;
+const createScfOperations = (scfClient) => ({
+    createFunction: async (config, codeBase64) => {
+        const params = {
+            FunctionName: config.FunctionName,
+            Code: {
+                ZipFile: codeBase64,
+            },
+            Handler: config.Handler,
+            Runtime: config.Runtime,
+            MemorySize: config.MemorySize,
+            Timeout: config.Timeout,
+            ...(config.Environment && { Environment: config.Environment }),
+        };
+        await scfClient.CreateFunction(params);
+    },
+    getFunction: async (functionName) => {
+        try {
+            const params = {
+                FunctionName: functionName,
+            };
+            const response = await scfClient.GetFunction(params);
+            if (!response || !response.FunctionName) {
+                return null;
+            }
+            const environment = response.Environment?.Variables
+                ? {
+                    Variables: response.Environment.Variables.map((v) => ({
+                        Key: v.Key || '',
+                        Value: v.Value || '',
+                    })),
+                }
+                : undefined;
+            const triggers = response.Triggers?.map((t) => ({
+                ModTime: t.ModTime || '',
+                Type: t.Type || '',
+                TriggerDesc: t.TriggerDesc || '',
+                TriggerName: t.TriggerName || '',
+                AddTime: t.AddTime || '',
+                Enable: t.Enable || 0,
+                CustomArgument: t.CustomArgument,
+                AvailableStatus: t.AvailableStatus,
+                ResourceId: t.ResourceId,
+                BindStatus: t.BindStatus,
+                TriggerAttribute: t.TriggerAttribute,
+                Qualifier: t.Qualifier,
+                Description: t.Description,
+            }));
+            const tags = response.Tags?.map((t) => ({
+                Key: t.Key || '',
+                Value: t.Value || '',
+            }));
+            return {
+                FunctionName: response.FunctionName || '',
+                Runtime: response.Runtime || '',
+                Handler: response.Handler || '',
+                MemorySize: response.MemorySize || 128,
+                Timeout: response.Timeout || 3,
+                Environment: environment,
+                ModTime: response.ModTime,
+                CodeSha256: undefined,
+                CodeInfo: response.CodeInfo,
+                Description: response.Description,
+                Triggers: triggers,
+                CodeSize: response.CodeSize,
+                FunctionVersion: response.FunctionVersion,
+                VpcConfig: response.VpcConfig,
+                UseGpu: response.UseGpu,
+                CodeResult: response.CodeResult,
+                CodeError: response.CodeError,
+                ErrNo: response.ErrNo,
+                Namespace: response.Namespace,
+                Role: response.Role,
+                InstallDependency: response.InstallDependency,
+                Status: response.Status,
+                StatusDesc: response.StatusDesc,
+                ClsLogsetId: response.ClsLogsetId,
+                ClsTopicId: response.ClsTopicId,
+                FunctionId: response.FunctionId,
+                Tags: tags,
+                EipConfig: response.EipConfig,
+                AccessInfo: response.AccessInfo,
+                Type: response.Type,
+                L5Enable: response.L5Enable,
+                Layers: response.Layers,
+                DeadLetterConfig: response.DeadLetterConfig,
+                AddTime: response.AddTime,
+                PublicNetConfig: response.PublicNetConfig,
+                OnsEnable: response.OnsEnable,
+                CfsConfig: response.CfsConfig,
+                AvailableStatus: response.AvailableStatus,
+                Qualifier: response.Qualifier,
+                InitTimeout: response.InitTimeout,
+                StatusReasons: response.StatusReasons,
+                AsyncRunEnable: response.AsyncRunEnable,
+                TraceEnable: response.TraceEnable,
+                ImageConfig: response.ImageConfig,
+                ProtocolType: response.ProtocolType,
+                ProtocolParams: response.ProtocolParams,
+                DnsCache: response.DnsCache,
+                IntranetConfig: response.IntranetConfig,
+            };
+        }
+        catch (error) {
+            if (error &&
+                typeof error === 'object' &&
+                'code' in error &&
+                error.code === 'ResourceNotFound.FunctionName') {
+                return null;
+            }
+            throw error;
+        }
+    },
+    updateFunctionConfiguration: async (config) => {
+        const params = {
+            FunctionName: config.FunctionName,
+            Handler: config.Handler,
+            Runtime: config.Runtime,
+            MemorySize: config.MemorySize,
+            Timeout: config.Timeout,
+            ...(config.Environment && { Environment: config.Environment }),
+        };
+        await scfClient.UpdateFunctionConfiguration(params);
+    },
+    updateFunctionCode: async (functionName, codeBase64) => {
+        const params = {
+            FunctionName: functionName,
+            ZipFile: codeBase64,
+        };
+        await scfClient.UpdateFunctionCode(params);
+    },
+    deleteFunction: async (functionName) => {
+        const params = {
+            FunctionName: functionName,
+        };
+        await scfClient.DeleteFunction(params);
+    },
+});
+exports.createScfOperations = createScfOperations;