@geek-fun/serverlessinsight 0.6.14 → 0.7.0

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

@@ -0,0 +1,99 @@
+"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 __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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createVolcengineClient = void 0;
+const openapi_1 = require("@volcengine/openapi");
+const vefaasOperations_1 = require("./vefaasOperations");
+const tosOperations_1 = require("./tosOperations");
+const iamOperations_1 = require("./iamOperations");
+const apigwOperations_1 = require("./apigwOperations");
+const tlsOperations_1 = require("./tlsOperations");
+__exportStar(require("./types"), exports);
+__exportStar(require("./vefaasOperations"), exports);
+__exportStar(require("./tosOperations"), exports);
+__exportStar(require("./iamOperations"), exports);
+__exportStar(require("./apigwOperations"), exports);
+__exportStar(require("./tlsOperations"), exports);
+const initializeSdkClients = (context) => {
+    const vefaasService = new openapi_1.Service({
+        serviceName: 'vefaas',
+        defaultVersion: '2024-06-06',
+        protocol: 'https',
+        host: 'vefaas.volcengineapi.com',
+        accessKeyId: context.accessKeyId,
+        secretKey: context.accessKeySecret,
+        region: context.region,
+        ...(context.securityToken && { sessionToken: context.securityToken }),
+    });
+    const tosService = new openapi_1.Service({
+        serviceName: 'tos',
+        defaultVersion: '2018-08-01',
+        protocol: 'https',
+        host: `tos-${context.region}.volces.com`,
+        accessKeyId: context.accessKeyId,
+        secretKey: context.accessKeySecret,
+        region: context.region,
+        ...(context.securityToken && { sessionToken: context.securityToken }),
+    });
+    const iamService = new openapi_1.Service({
+        serviceName: 'iam',
+        defaultVersion: '2024-01-01',
+        protocol: 'https',
+        host: 'iam.volcengineapi.com',
+        accessKeyId: context.accessKeyId,
+        secretKey: context.accessKeySecret,
+        region: context.region,
+        ...(context.securityToken && { sessionToken: context.securityToken }),
+    });
+    const tlsService = new openapi_1.Service({
+        serviceName: 'tls',
+        defaultVersion: '2024-01-01',
+        protocol: 'https',
+        host: `tls.${context.region}.volces.com`,
+        accessKeyId: context.accessKeyId,
+        secretKey: context.accessKeySecret,
+        region: context.region,
+        ...(context.securityToken && { sessionToken: context.securityToken }),
+    });
+    const apigwService = new openapi_1.Service({
+        serviceName: 'apig',
+        defaultVersion: '2021-03-03',
+        protocol: 'https',
+        host: 'apig.volcengineapi.com',
+        accessKeyId: context.accessKeyId,
+        secretKey: context.accessKeySecret,
+        region: context.region,
+        ...(context.securityToken && { sessionToken: context.securityToken }),
+    });
+    return {
+        vefaas: vefaasService,
+        tos: tosService,
+        iam: iamService,
+        tls: tlsService,
+        apigw: apigwService,
+    };
+};
+const createVolcengineClient = (context) => {
+    const sdkClients = initializeSdkClients(context);
+    return {
+        vefaas: (0, vefaasOperations_1.createVefaasOperations)(sdkClients.vefaas),
+        tos: (0, tosOperations_1.createTosOperations)(sdkClients.tos, context.region),
+        iam: (0, iamOperations_1.createIamOperations)(sdkClients.iam),
+        tls: (0, tlsOperations_1.createTlsOperations)(sdkClients.tls),
+        apigw: (0, apigwOperations_1.createApigwOperations)(sdkClients.apigw),
+    };
+};
+exports.createVolcengineClient = createVolcengineClient;

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

@@ -0,0 +1,256 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTlsOperations = void 0;
+const logger_1 = require("../logger");
+const lang_1 = require("../../lang");
+const WAIT_INTERVAL_MS = 5000;
+const MAX_WAIT_ATTEMPTS = 30;
+const delay = (ms) => new Promise((resolve) => {
+    setTimeout(resolve, ms);
+});
+const createTlsOperations = (tlsClient) => {
+    return {
+        createProject: async (config) => {
+            const response = await tlsClient.fetchOpenAPI({
+                Action: 'CreateProject',
+                Version: '2024-01-01',
+                method: 'POST',
+                headers: { 'content-type': 'application/json' },
+                data: {
+                    ProjectName: config.projectName,
+                    Description: config.description,
+                    Region: config.region,
+                },
+            });
+            const data = (response.Result || {});
+            logger_1.logger.info(lang_1.lang.__('TLS_PROJECT_CREATED', { projectName: config.projectName }));
+            return {
+                projectId: data.ProjectId,
+                projectName: config.projectName,
+                description: config.description,
+                region: config.region,
+                createTime: data.CreateTime,
+                status: data.Status,
+            };
+        },
+        getProject: async (projectName) => {
+            try {
+                const response = await tlsClient.fetchOpenAPI({
+                    Action: 'GetProject',
+                    Version: '2024-01-01',
+                    method: 'POST',
+                    headers: { 'content-type': 'application/json' },
+                    data: { ProjectName: projectName },
+                });
+                const data = (response.Result || {});
+                return {
+                    projectId: data.ProjectId,
+                    projectName: data.ProjectName,
+                    description: data.Description,
+                    region: data.Region,
+                    createTime: data.CreateTime,
+                    status: data.Status,
+                };
+            }
+            catch (error) {
+                if (error && typeof error === 'object' && 'code' in error) {
+                    if (error.code === 'ProjectNotFound' || error.code === 'ResourceNotFound') {
+                        return null;
+                    }
+                }
+                throw error;
+            }
+        },
+        deleteProject: async (projectName) => {
+            try {
+                await tlsClient.fetchOpenAPI({
+                    Action: 'DeleteProject',
+                    Version: '2024-01-01',
+                    method: 'POST',
+                    headers: { 'content-type': 'application/json' },
+                    data: { ProjectName: projectName },
+                });
+                logger_1.logger.info(lang_1.lang.__('TLS_PROJECT_DELETED', { projectName }));
+            }
+            catch (error) {
+                if (error && typeof error === 'object' && 'code' in error) {
+                    if (error.code === 'ProjectNotFound' || error.code === 'ResourceNotFound') {
+                        logger_1.logger.warn(lang_1.lang.__('TLS_PROJECT_NOT_FOUND', { projectName }));
+                        return;
+                    }
+                }
+                throw error;
+            }
+        },
+        createTopic: async (config) => {
+            const response = await tlsClient.fetchOpenAPI({
+                Action: 'CreateTopic',
+                Version: '2024-01-01',
+                method: 'POST',
+                headers: { 'content-type': 'application/json' },
+                data: {
+                    ProjectName: config.projectName,
+                    TopicName: config.topicName,
+                    Description: config.description,
+                    TTL: config.ttl ?? 30,
+                },
+            });
+            const data = (response.Result || {});
+            logger_1.logger.info(lang_1.lang.__('TLS_TOPIC_CREATED', { topicName: config.topicName }));
+            return {
+                topicId: data.TopicId,
+                topicName: config.topicName,
+                projectName: config.projectName,
+                description: config.description,
+                ttl: config.ttl,
+                createTime: data.CreateTime,
+                status: data.Status,
+            };
+        },
+        getTopic: async (projectName, topicName) => {
+            try {
+                const response = await tlsClient.fetchOpenAPI({
+                    Action: 'GetTopic',
+                    Version: '2024-01-01',
+                    method: 'POST',
+                    headers: { 'content-type': 'application/json' },
+                    data: {
+                        ProjectName: projectName,
+                        TopicName: topicName,
+                    },
+                });
+                const data = (response.Result || {});
+                return {
+                    topicId: data.TopicId,
+                    topicName: data.TopicName,
+                    projectName: data.ProjectName,
+                    description: data.Description,
+                    ttl: data.TTL,
+                    createTime: data.CreateTime,
+                    status: data.Status,
+                };
+            }
+            catch (error) {
+                if (error && typeof error === 'object' && 'code' in error) {
+                    if (error.code === 'TopicNotFound' || error.code === 'ResourceNotFound') {
+                        return null;
+                    }
+                }
+                throw error;
+            }
+        },
+        deleteTopic: async (projectName, topicName) => {
+            try {
+                await tlsClient.fetchOpenAPI({
+                    Action: 'DeleteTopic',
+                    Version: '2024-01-01',
+                    method: 'POST',
+                    headers: { 'content-type': 'application/json' },
+                    data: {
+                        ProjectName: projectName,
+                        TopicName: topicName,
+                    },
+                });
+                logger_1.logger.info(lang_1.lang.__('TLS_TOPIC_DELETED', { topicName }));
+            }
+            catch (error) {
+                if (error && typeof error === 'object' && 'code' in error) {
+                    if (error.code === 'TopicNotFound' || error.code === 'ResourceNotFound') {
+                        logger_1.logger.warn(lang_1.lang.__('TLS_TOPIC_NOT_FOUND', { topicName }));
+                        return;
+                    }
+                }
+                throw error;
+            }
+        },
+        createIndex: async (config) => {
+            await tlsClient.fetchOpenAPI({
+                Action: 'CreateIndex',
+                Version: '2024-01-01',
+                method: 'POST',
+                headers: { 'content-type': 'application/json' },
+                data: {
+                    ProjectName: config.projectName,
+                    TopicName: config.topicName,
+                    FullTextIndex: config.fullTextIndex
+                        ? {
+                            Delimiter: config.fullTextIndex.delimiter ?? ' ,.?;!\n\t',
+                            CaseSensitive: config.fullTextIndex.caseSensitive ?? false,
+                        }
+                        : undefined,
+                    KeyValueIndex: config.keyValueIndex,
+                },
+            });
+            logger_1.logger.info(lang_1.lang.__('TLS_INDEX_CREATED', { topicName: config.topicName }));
+        },
+        deleteIndex: async (projectName, topicName) => {
+            try {
+                await tlsClient.fetchOpenAPI({
+                    Action: 'DeleteIndex',
+                    Version: '2024-01-01',
+                    method: 'POST',
+                    headers: { 'content-type': 'application/json' },
+                    data: {
+                        ProjectName: projectName,
+                        TopicName: topicName,
+                    },
+                });
+                logger_1.logger.info(lang_1.lang.__('TLS_INDEX_DELETED', { topicName }));
+            }
+            catch (error) {
+                if (error && typeof error === 'object' && 'code' in error) {
+                    if (error.code === 'IndexNotFound' || error.code === 'ResourceNotFound') {
+                        return;
+                    }
+                }
+                throw error;
+            }
+        },
+        waitForProject: async (projectName) => {
+            for (let attempt = 0; attempt < MAX_WAIT_ATTEMPTS; attempt++) {
+                const project = await tlsClient.fetchOpenAPI({
+                    Action: 'GetProject',
+                    Version: '2024-01-01',
+                    method: 'POST',
+                    headers: { 'content-type': 'application/json' },
+                    data: { ProjectName: projectName },
+                });
+                const data = (project.Result || {});
+                const status = data.Status;
+                if (status === 'Active') {
+                    return;
+                }
+                if (status === 'Failed' || status === 'Error') {
+                    throw new Error(lang_1.lang.__('TLS_PROJECT_FAILED', { projectName }));
+                }
+                await delay(WAIT_INTERVAL_MS);
+            }
+            throw new Error(lang_1.lang.__('TLS_PROJECT_TIMEOUT', { projectName }));
+        },
+        waitForTopic: async (projectName, topicName) => {
+            for (let attempt = 0; attempt < MAX_WAIT_ATTEMPTS; attempt++) {
+                const topic = await tlsClient.fetchOpenAPI({
+                    Action: 'GetTopic',
+                    Version: '2024-01-01',
+                    method: 'POST',
+                    headers: { 'content-type': 'application/json' },
+                    data: {
+                        ProjectName: projectName,
+                        TopicName: topicName,
+                    },
+                });
+                const data = (topic.Result || {});
+                const status = data.Status;
+                if (status === 'Active') {
+                    return;
+                }
+                if (status === 'Failed' || status === 'Error') {
+                    throw new Error(lang_1.lang.__('TLS_TOPIC_FAILED', { topicName }));
+                }
+                await delay(WAIT_INTERVAL_MS);
+            }
+            throw new Error(lang_1.lang.__('TLS_TOPIC_TIMEOUT', { topicName }));
+        },
+    };
+};
+exports.createTlsOperations = createTlsOperations;