@geek-fun/serverlessinsight 0.6.14 → 0.7.0

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

@@ -0,0 +1,440 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTosOperations = void 0;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const logger_1 = require("../logger");
+const lang_1 = require("../../lang");
+const TOS_ACL_VALUES = ['private', 'public-read', 'public-read-write'];
+const getContentType = (filePath) => {
+    const ext = path.extname(filePath).toLowerCase();
+    const contentTypes = {
+        '.html': 'text/html',
+        '.css': 'text/css',
+        '.js': 'application/javascript',
+        '.json': 'application/json',
+        '.png': 'image/png',
+        '.jpg': 'image/jpeg',
+        '.jpeg': 'image/jpeg',
+        '.gif': 'image/gif',
+        '.svg': 'image/svg+xml',
+        '.ico': 'image/x-icon',
+        '.woff': 'font/woff',
+        '.woff2': 'font/woff2',
+        '.ttf': 'font/ttf',
+        '.eot': 'application/vnd.ms-fontobject',
+        '.mp4': 'video/mp4',
+        '.webm': 'video/webm',
+        '.mp3': 'audio/mpeg',
+        '.pdf': 'application/pdf',
+        '.zip': 'application/zip',
+        '.xml': 'application/xml',
+        '.txt': 'text/plain',
+    };
+    return contentTypes[ext] || 'application/octet-stream';
+};
+const createTosOperations = (client, _region) => {
+    return {
+        createBucket: async (config) => {
+            if (!client) {
+                throw new Error(lang_1.lang.__('VOLCENGINE_TOS_CLIENT_NOT_INITIALIZED'));
+            }
+            const params = {
+                Bucket: config.bucketName,
+            };
+            if (config.acl && TOS_ACL_VALUES.includes(config.acl)) {
+                params.ACL = config.acl;
+            }
+            if (config.storageClass) {
+                params.StorageClass = config.storageClass;
+            }
+            await client.fetchOpenAPI({
+                Action: 'CreateBucket',
+                Version: '2018-08-01',
+                method: 'PUT',
+                headers: {
+                    'content-type': 'application/xml',
+                },
+                query: params,
+            });
+            logger_1.logger.info(lang_1.lang.__('TOS_BUCKET_CREATED', { bucketName: config.bucketName }));
+            if (config.websiteConfig) {
+                await client.fetchOpenAPI({
+                    Action: 'PutBucketWebsite',
+                    Version: '2018-08-01',
+                    method: 'PUT',
+                    headers: {
+                        'content-type': 'application/xml',
+                    },
+                    query: {
+                        Bucket: config.bucketName,
+                    },
+                    data: {
+                        IndexDocument: {
+                            Suffix: config.websiteConfig.indexDocument,
+                        },
+                        ...(config.websiteConfig.errorDocument && {
+                            ErrorDocument: {
+                                Key: config.websiteConfig.errorDocument,
+                            },
+                        }),
+                    },
+                });
+                logger_1.logger.info(lang_1.lang.__('TOS_BUCKET_WEBSITE_CONFIGURED', { bucketName: config.bucketName }));
+            }
+            const bucketInfo = await (async () => {
+                const response = await client.fetchOpenAPI({
+                    Action: 'GetBucketInfo',
+                    Version: '2018-08-01',
+                    method: 'GET',
+                    query: {
+                        Bucket: config.bucketName,
+                    },
+                });
+                const result = (response.Result || {});
+                const bucketData = (result.BucketInfo || {});
+                return {
+                    name: config.bucketName,
+                    location: bucketData.Location,
+                    creationDate: bucketData.CreationDate,
+                    storageClass: bucketData.StorageClass,
+                    extranetEndpoint: bucketData.ExtranetEndpoint,
+                    intranetEndpoint: bucketData.IntranetEndpoint,
+                    acl: bucketData.ACL,
+                };
+            })();
+            return bucketInfo;
+        },
+        getBucket: async (bucketName) => {
+            if (!client) {
+                throw new Error(lang_1.lang.__('VOLCENGINE_TOS_CLIENT_NOT_INITIALIZED'));
+            }
+            try {
+                const response = await client.fetchOpenAPI({
+                    Action: 'GetBucketInfo',
+                    Version: '2018-08-01',
+                    method: 'GET',
+                    query: {
+                        Bucket: bucketName,
+                    },
+                });
+                const result = (response.Result || {});
+                const bucketData = (result.BucketInfo || {});
+                let websiteConfig;
+                try {
+                    const websiteResponse = await client.fetchOpenAPI({
+                        Action: 'GetBucketWebsite',
+                        Version: '2018-08-01',
+                        method: 'GET',
+                        query: {
+                            Bucket: bucketName,
+                        },
+                    });
+                    const websiteResult = (websiteResponse.Result || {});
+                    if (websiteResult.IndexDocument) {
+                        const indexDoc = websiteResult.IndexDocument;
+                        websiteConfig = {
+                            indexDocument: indexDoc.Suffix,
+                        };
+                        if (websiteResult.ErrorDocument) {
+                            const errorDoc = websiteResult.ErrorDocument;
+                            websiteConfig.errorDocument = errorDoc.Key;
+                        }
+                    }
+                }
+                catch {
+                    // Website config may not exist
+                }
+                return {
+                    name: bucketName,
+                    location: bucketData.Location,
+                    creationDate: bucketData.CreationDate,
+                    storageClass: bucketData.StorageClass,
+                    extranetEndpoint: bucketData.ExtranetEndpoint,
+                    intranetEndpoint: bucketData.IntranetEndpoint,
+                    acl: bucketData.ACL,
+                    websiteConfig,
+                };
+            }
+            catch (error) {
+                if (error &&
+                    typeof error === 'object' &&
+                    'code' in error &&
+                    (error.code === 'NoSuchBucket' || error.code === 'ResourceNotFound')) {
+                    return null;
+                }
+                throw error;
+            }
+        },
+        updateBucketAcl: async (bucketName, acl) => {
+            if (!client) {
+                throw new Error(lang_1.lang.__('VOLCENGINE_TOS_CLIENT_NOT_INITIALIZED'));
+            }
+            await client.fetchOpenAPI({
+                Action: 'PutBucketAcl',
+                Version: '2018-08-01',
+                method: 'PUT',
+                headers: {
+                    'content-type': 'application/xml',
+                },
+                query: {
+                    Bucket: bucketName,
+                    ACL: acl,
+                },
+            });
+            logger_1.logger.info(lang_1.lang.__('TOS_BUCKET_ACL_UPDATED', { bucketName, acl }));
+        },
+        updateBucketWebsite: async (bucketName, websiteConfig) => {
+            if (!client) {
+                throw new Error(lang_1.lang.__('VOLCENGINE_TOS_CLIENT_NOT_INITIALIZED'));
+            }
+            const data = {
+                IndexDocument: {
+                    Suffix: websiteConfig.indexDocument,
+                },
+            };
+            if (websiteConfig.errorDocument) {
+                data.ErrorDocument = {
+                    Key: websiteConfig.errorDocument,
+                };
+            }
+            await client.fetchOpenAPI({
+                Action: 'PutBucketWebsite',
+                Version: '2018-08-01',
+                method: 'PUT',
+                headers: {
+                    'content-type': 'application/xml',
+                },
+                query: {
+                    Bucket: bucketName,
+                },
+                data,
+            });
+            logger_1.logger.info(lang_1.lang.__('TOS_BUCKET_WEBSITE_UPDATED', { bucketName }));
+        },
+        deleteBucket: async (bucketName) => {
+            if (!client) {
+                throw new Error(lang_1.lang.__('VOLCENGINE_TOS_CLIENT_NOT_INITIALIZED'));
+            }
+            try {
+                let continuationToken;
+                do {
+                    const listResponse = await client.fetchOpenAPI({
+                        Action: 'ListObjectsType2',
+                        Version: '2018-08-01',
+                        method: 'GET',
+                        query: {
+                            Bucket: bucketName,
+                            'list-type': '2',
+                            ...(continuationToken && { 'continuation-token': continuationToken }),
+                        },
+                    });
+                    const listResult = (listResponse.Result || {});
+                    const contents = (listResult.Contents || []);
+                    if (contents.length > 0) {
+                        const objects = contents.map((obj) => ({ Key: obj.Key }));
+                        await client.fetchOpenAPI({
+                            Action: 'DeleteMultipleObjects',
+                            Version: '2018-08-01',
+                            method: 'POST',
+                            headers: {
+                                'content-type': 'application/xml',
+                            },
+                            query: {
+                                Bucket: bucketName,
+                            },
+                            data: {
+                                Delete: {
+                                    Object: objects,
+                                },
+                            },
+                        });
+                    }
+                    continuationToken = listResult.NextContinuationToken;
+                } while (continuationToken);
+                await client.fetchOpenAPI({
+                    Action: 'DeleteBucket',
+                    Version: '2018-08-01',
+                    method: 'DELETE',
+                    query: {
+                        Bucket: bucketName,
+                    },
+                });
+                logger_1.logger.info(lang_1.lang.__('TOS_BUCKET_DELETED', { bucketName }));
+            }
+            catch (error) {
+                if (error &&
+                    typeof error === 'object' &&
+                    'code' in error &&
+                    (error.code === 'NoSuchBucket' || error.code === 'ResourceNotFound')) {
+                    logger_1.logger.warn(lang_1.lang.__('RESOURCE_NOT_FOUND_PROVIDER', { resourceType: 'Bucket', name: bucketName }));
+                    return;
+                }
+                throw error;
+            }
+        },
+        putObject: async (bucket, key, body) => {
+            if (!client) {
+                throw new Error(lang_1.lang.__('VOLCENGINE_TOS_CLIENT_NOT_INITIALIZED'));
+            }
+            await client.fetchOpenAPI({
+                Action: 'PutObject',
+                Version: '2018-08-01',
+                method: 'PUT',
+                headers: {
+                    'content-type': getContentType(key),
+                },
+                query: {
+                    Bucket: bucket,
+                    Key: key,
+                },
+                data: body,
+            });
+        },
+        listObjects: async (bucket, prefix) => {
+            if (!client) {
+                throw new Error(lang_1.lang.__('VOLCENGINE_TOS_CLIENT_NOT_INITIALIZED'));
+            }
+            const objects = [];
+            let continuationToken;
+            do {
+                const response = await client.fetchOpenAPI({
+                    Action: 'ListObjectsType2',
+                    Version: '2018-08-01',
+                    method: 'GET',
+                    query: {
+                        Bucket: bucket,
+                        'list-type': '2',
+                        ...(prefix && { Prefix: prefix }),
+                        ...(continuationToken && { 'continuation-token': continuationToken }),
+                    },
+                });
+                const result = (response.Result || {});
+                const contents = (result.Contents || []);
+                for (const obj of contents) {
+                    objects.push({
+                        key: obj.Key,
+                        size: obj.Size,
+                        lastModified: obj.LastModified,
+                        etag: obj.ETag,
+                    });
+                }
+                continuationToken = result.NextContinuationToken;
+            } while (continuationToken);
+            return objects;
+        },
+        deleteObjects: async (bucket, keys) => {
+            if (!client) {
+                throw new Error(lang_1.lang.__('VOLCENGINE_TOS_CLIENT_NOT_INITIALIZED'));
+            }
+            if (keys.length === 0)
+                return;
+            const objects = keys.map((key) => ({ Key: key }));
+            await client.fetchOpenAPI({
+                Action: 'DeleteMultipleObjects',
+                Version: '2018-08-01',
+                method: 'POST',
+                headers: {
+                    'content-type': 'application/xml',
+                },
+                query: {
+                    Bucket: bucket,
+                },
+                data: {
+                    Delete: {
+                        Object: objects,
+                    },
+                },
+            });
+        },
+        uploadFiles: async (bucketName, sourcePath) => {
+            if (!client) {
+                throw new Error(lang_1.lang.__('VOLCENGINE_TOS_CLIENT_NOT_INITIALIZED'));
+            }
+            const uploadDirectory = async (dirPath, prefix = '') => {
+                const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+                for (const entry of entries) {
+                    const fullPath = path.join(dirPath, entry.name);
+                    const objectKey = prefix ? `${prefix}/${entry.name}` : entry.name;
+                    if (entry.isDirectory()) {
+                        await uploadDirectory(fullPath, objectKey);
+                    }
+                    else if (entry.isFile()) {
+                        const fileContent = fs.readFileSync(fullPath);
+                        const contentType = getContentType(fullPath);
+                        await client.fetchOpenAPI({
+                            Action: 'PutObject',
+                            Version: '2018-08-01',
+                            method: 'PUT',
+                            headers: {
+                                'content-type': contentType,
+                            },
+                            query: {
+                                Bucket: bucketName,
+                                Key: objectKey,
+                            },
+                            data: fileContent,
+                        });
+                        logger_1.logger.debug(lang_1.lang.__('TOS_OBJECT_UPLOADED', { bucket: bucketName, key: objectKey }));
+                    }
+                }
+            };
+            const stats = fs.statSync(sourcePath);
+            if (stats.isDirectory()) {
+                await uploadDirectory(sourcePath);
+            }
+            else {
+                const fileName = path.basename(sourcePath);
+                const fileContent = fs.readFileSync(sourcePath);
+                await client.fetchOpenAPI({
+                    Action: 'PutObject',
+                    Version: '2018-08-01',
+                    method: 'PUT',
+                    headers: {
+                        'content-type': getContentType(sourcePath),
+                    },
+                    query: {
+                        Bucket: bucketName,
+                        Key: fileName,
+                    },
+                    data: fileContent,
+                });
+            }
+            logger_1.logger.info(lang_1.lang.__('TOS_FILES_UPLOADED', { bucket: bucketName, path: sourcePath }));
+        },
+    };
+};
+exports.createTosOperations = createTosOperations;

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildVolcengineEndpoint = exports.VOLCENGINE_REGIONS = void 0;
+// ============================================================================
+// Volcengine Regions
+// ============================================================================
+/**
+ * Supported Volcengine regions
+ * @see https://www.volcengine.com/docs/6662/107381
+ */
+exports.VOLCENGINE_REGIONS = {
+    CN_BEIJING: 'cn-beijing',
+    CN_SHANGHAI: 'cn-shanghai',
+    CN_GUANGZHOU: 'cn-guangzhou',
+    AP_SOUTHEAST_1: 'ap-southeast-1',
+};
+// ============================================================================
+// Volcengine Endpoints
+// ============================================================================
+/**
+ * Build service endpoint for Volcengine services
+ */
+const buildVolcengineEndpoint = (service, region) => {
+    return `${service}.${region}.volces.com`;
+};
+exports.buildVolcengineEndpoint = buildVolcengineEndpoint;