@geek-fun/serverlessinsight 0.4.0 → 0.5.0

package/dist/src/common/aliyunClient/ossOperations.js

@@ -0,0 +1,237 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOssOperations = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const createOssOperations = (ossClient, region) => {
+    const useBucket = (bucketName) => {
+        ossClient.useBucket(bucketName);
+    };
+    return {
+        createBucket: async (config) => {
+            if (config.storageClass) {
+                await ossClient.putBucket(config.bucketName, {
+                    storageClass: config.storageClass,
+                });
+            }
+            else {
+                await ossClient.putBucket(config.bucketName);
+            }
+            // Set ACL if specified
+            if (config.acl) {
+                useBucket(config.bucketName);
+                await ossClient.putBucketACL(config.bucketName, config.acl);
+            }
+            // Set website configuration if specified
+            if (config.websiteConfig) {
+                useBucket(config.bucketName);
+                await ossClient.putBucketWebsite(config.bucketName, {
+                    index: config.websiteConfig.indexDocument,
+                    error: config.websiteConfig.errorDocument,
+                });
+            }
+            return {
+                name: config.bucketName,
+                location: `oss-${region}`,
+                acl: config.acl,
+                websiteConfig: config.websiteConfig,
+                storageClass: config.storageClass,
+            };
+        },
+        getBucket: async (bucketName) => {
+            try {
+                useBucket(bucketName);
+                // Get bucket info
+                const infoResult = await ossClient.getBucketInfo(bucketName);
+                const bucket = infoResult.bucket;
+                // Get ACL
+                let acl;
+                try {
+                    const aclResult = await ossClient.getBucketACL(bucketName);
+                    acl = aclResult.acl;
+                }
+                catch {
+                    // ACL might not be accessible
+                }
+                // Get website config
+                let websiteConfig;
+                try {
+                    const websiteResult = await ossClient.getBucketWebsite(bucketName);
+                    if (websiteResult.index) {
+                        websiteConfig = {
+                            indexDocument: websiteResult.index,
+                            errorDocument: websiteResult.error,
+                        };
+                    }
+                }
+                catch {
+                    // Website config might not exist
+                }
+                // Get logging config
+                let loggingConfig;
+                try {
+                    const loggingResult = await ossClient.getBucketLogging(bucketName);
+                    if (loggingResult.enable && loggingResult.prefix) {
+                        loggingConfig = {
+                            targetPrefix: loggingResult.prefix,
+                        };
+                    }
+                }
+                catch {
+                    // Logging config might not exist
+                }
+                // Get CORS rules
+                let corsRules;
+                try {
+                    const corsResult = await ossClient.getBucketCORS(bucketName);
+                    if (corsResult.rules && corsResult.rules.length > 0) {
+                        corsRules = corsResult.rules.map((rule) => ({
+                            allowedOrigins: Array.isArray(rule.allowedOrigin)
+                                ? rule.allowedOrigin
+                                : [rule.allowedOrigin],
+                            allowedMethods: Array.isArray(rule.allowedMethod)
+                                ? rule.allowedMethod
+                                : [rule.allowedMethod],
+                            allowedHeaders: rule.allowedHeader
+                                ? Array.isArray(rule.allowedHeader)
+                                    ? rule.allowedHeader
+                                    : [rule.allowedHeader]
+                                : undefined,
+                            exposeHeaders: rule.exposeHeader
+                                ? Array.isArray(rule.exposeHeader)
+                                    ? rule.exposeHeader
+                                    : [rule.exposeHeader]
+                                : undefined,
+                            maxAgeSeconds: typeof rule.maxAgeSeconds === 'number' ? rule.maxAgeSeconds : undefined,
+                        }));
+                    }
+                }
+                catch {
+                    // CORS config might not exist
+                }
+                // Get lifecycle rules
+                let lifecycleRules;
+                try {
+                    const lifecycleResult = await ossClient.getBucketLifecycle(bucketName);
+                    if (lifecycleResult.rules && lifecycleResult.rules.length > 0) {
+                        lifecycleRules = lifecycleResult.rules.map((rule) => ({
+                            id: rule.id,
+                            status: rule.status,
+                            prefix: rule.prefix,
+                            expiration: rule.days
+                                ? {
+                                    days: typeof rule.days === 'number' ? rule.days : parseInt(rule.days, 10),
+                                }
+                                : rule.date
+                                    ? {
+                                        date: rule.date,
+                                    }
+                                    : undefined,
+                        }));
+                    }
+                }
+                catch {
+                    // Lifecycle config might not exist
+                }
+                // Build owner info
+                const owner = bucket?.Owner
+                    ? {
+                        id: bucket.Owner.ID,
+                        displayName: bucket.Owner.DisplayName,
+                    }
+                    : undefined;
+                return {
+                    name: bucketName,
+                    location: bucket?.Location,
+                    creationDate: bucket?.CreationDate,
+                    storageClass: bucket?.StorageClass,
+                    dataRedundancyType: bucket?.DataRedundancyType,
+                    resourceGroupId: bucket?.ResourceGroupId,
+                    comment: bucket?.Comment,
+                    owner,
+                    blockPublicAccess: bucket?.BlockPublicAccess,
+                    accessMonitorStatus: bucket?.AccessMonitor,
+                    acl,
+                    websiteConfig,
+                    loggingConfig,
+                    corsRules,
+                    lifecycleRules,
+                };
+            }
+            catch (error) {
+                if (error &&
+                    typeof error === 'object' &&
+                    'code' in error &&
+                    (error.code === 'NoSuchBucket' || error.code === 'AccessDenied')) {
+                    return null;
+                }
+                throw error;
+            }
+        },
+        updateBucketAcl: async (bucketName, acl) => {
+            useBucket(bucketName);
+            await ossClient.putBucketACL(bucketName, acl);
+        },
+        updateBucketWebsite: async (bucketName, websiteConfig) => {
+            useBucket(bucketName);
+            await ossClient.putBucketWebsite(bucketName, {
+                index: websiteConfig.indexDocument,
+                error: websiteConfig.errorDocument,
+            });
+        },
+        deleteBucketWebsite: async (bucketName) => {
+            useBucket(bucketName);
+            await ossClient.deleteBucketWebsite(bucketName);
+        },
+        deleteBucket: async (bucketName) => {
+            useBucket(bucketName);
+            // List and delete all objects first
+            try {
+                let marker;
+                do {
+                    const listResult = await ossClient.list({
+                        'max-keys': 1000,
+                        marker,
+                    }, {});
+                    if (listResult.objects && listResult.objects.length > 0) {
+                        const keys = listResult.objects.map((obj) => obj.name);
+                        await ossClient.deleteMulti(keys, { quiet: true });
+                    }
+                    marker = listResult.isTruncated ? listResult.nextMarker : undefined;
+                } while (marker);
+            }
+            catch {
+                // Ignore errors when listing/deleting objects
+            }
+            await ossClient.deleteBucket(bucketName);
+        },
+        uploadFiles: async (bucketName, sourcePath) => {
+            useBucket(bucketName);
+            const uploadDirectory = async (dirPath, prefix = '') => {
+                const entries = node_fs_1.default.readdirSync(dirPath, { withFileTypes: true });
+                for (const entry of entries) {
+                    const fullPath = node_path_1.default.join(dirPath, entry.name);
+                    const ossKey = prefix ? `${prefix}/${entry.name}` : entry.name;
+                    if (entry.isDirectory()) {
+                        await uploadDirectory(fullPath, ossKey);
+                    }
+                    else if (entry.isFile()) {
+                        await ossClient.put(ossKey, fullPath);
+                    }
+                }
+            };
+            const stats = node_fs_1.default.statSync(sourcePath);
+            if (stats.isDirectory()) {
+                await uploadDirectory(sourcePath);
+            }
+            else {
+                const fileName = node_path_1.default.basename(sourcePath);
+                await ossClient.put(fileName, sourcePath);
+            }
+        },
+    };
+};
+exports.createOssOperations = createOssOperations;

package/dist/src/common/aliyunClient/ramOperations.js

@@ -0,0 +1,205 @@
+"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.createRamOperations = void 0;
+const ram = __importStar(require("@alicloud/ram20150501"));
+const FC_ASSUME_ROLE_POLICY = JSON.stringify({
+    Version: '1',
+    Statement: [
+        {
+            Action: 'sts:AssumeRole',
+            Effect: 'Allow',
+            Principal: {
+                Service: ['fc.aliyuncs.com'],
+            },
+        },
+    ],
+});
+const FC_EXECUTION_POLICY = JSON.stringify({
+    Version: '1',
+    Statement: [
+        {
+            Effect: 'Allow',
+            Action: [
+                'log:PostLogStoreLogs',
+                'log:CreateLogStore',
+                'log:GetLogStore',
+                'log:ListShards',
+                'log:GetCursorOrData',
+            ],
+            Resource: '*',
+        },
+        {
+            Effect: 'Allow',
+            Action: ['nas:*'],
+            Resource: '*',
+        },
+        {
+            Effect: 'Allow',
+            Action: [
+                'ecs:CreateNetworkInterface',
+                'ecs:DeleteNetworkInterface',
+                'ecs:DescribeNetworkInterfaces',
+                'ecs:CreateNetworkInterfacePermission',
+                'ecs:DescribeNetworkInterfacePermissions',
+                'ecs:DeleteNetworkInterfacePermission',
+            ],
+            Resource: '*',
+        },
+        {
+            Effect: 'Allow',
+            Action: ['vpc:DescribeVSwitchAttributes'],
+            Resource: '*',
+        },
+    ],
+});
+const createRamOperations = (ramClient) => {
+    const attachRolePolicyForFc = async (roleName) => {
+        const policyName = `${roleName}-policy`;
+        // Create policy
+        try {
+            const createPolicyRequest = new ram.CreatePolicyRequest({
+                policyName,
+                policyDocument: FC_EXECUTION_POLICY,
+                description: `FC execution policy for ${roleName}`,
+            });
+            await ramClient.createPolicy(createPolicyRequest);
+        }
+        catch (error) {
+            // Policy may already exist
+            if (!(error &&
+                typeof error === 'object' &&
+                'code' in error &&
+                error.code === 'EntityAlreadyExists.Policy')) {
+                throw error;
+            }
+        }
+        // Attach policy to role
+        try {
+            const attachRequest = new ram.AttachPolicyToRoleRequest({
+                policyType: 'Custom',
+                policyName,
+                roleName,
+            });
+            await ramClient.attachPolicyToRole(attachRequest);
+        }
+        catch (error) {
+            // Policy may already be attached
+            if (!(error &&
+                typeof error === 'object' &&
+                'code' in error &&
+                error.code === 'EntityAlreadyExists.Role.Policy')) {
+                throw error;
+            }
+        }
+    };
+    return {
+        createRole: async (roleName, description) => {
+            const request = new ram.CreateRoleRequest({
+                roleName,
+                assumeRolePolicyDocument: FC_ASSUME_ROLE_POLICY,
+                description: description ?? `ServerlessInsight FC execution role for ${roleName}`,
+            });
+            const response = await ramClient.createRole(request);
+            // Attach policy to role
+            await attachRolePolicyForFc(roleName);
+            return {
+                roleName,
+                roleId: response.body?.role?.roleId,
+                arn: response.body?.role?.arn,
+                description: response.body?.role?.description,
+                createDate: response.body?.role?.createDate,
+            };
+        },
+        getRole: async (roleName) => {
+            try {
+                const request = new ram.GetRoleRequest({
+                    roleName,
+                });
+                const response = await ramClient.getRole(request);
+                if (!response || !response.body || !response.body.role) {
+                    return null;
+                }
+                return {
+                    roleName: response.body.role.roleName ?? roleName,
+                    roleId: response.body.role.roleId,
+                    arn: response.body.role.arn,
+                    description: response.body.role.description,
+                    createDate: response.body.role.createDate,
+                };
+            }
+            catch (error) {
+                if (error &&
+                    typeof error === 'object' &&
+                    'code' in error &&
+                    error.code === 'EntityNotExist.Role') {
+                    return null;
+                }
+                throw error;
+            }
+        },
+        deleteRole: async (roleName) => {
+            const policyName = `${roleName}-policy`;
+            // Detach policy from role
+            try {
+                const detachRequest = new ram.DetachPolicyFromRoleRequest({
+                    policyType: 'Custom',
+                    policyName,
+                    roleName,
+                });
+                await ramClient.detachPolicyFromRole(detachRequest);
+            }
+            catch {
+                // Ignore if policy is not attached
+            }
+            // Delete policy
+            try {
+                const deletePolicyRequest = new ram.DeletePolicyRequest({
+                    policyName,
+                });
+                await ramClient.deletePolicy(deletePolicyRequest);
+            }
+            catch {
+                // Ignore if policy doesn't exist
+            }
+            // Delete role
+            const request = new ram.DeleteRoleRequest({
+                roleName,
+            });
+            await ramClient.deleteRole(request);
+        },
+    };
+};
+exports.createRamOperations = createRamOperations;

package/dist/src/common/aliyunClient/rdsOperations.js

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRdsOperations = exports.RdsInstanceStatus = void 0;
+const logger_1 = require("../logger");
+const lang_1 = require("../../lang");
+var RdsInstanceStatus;
+(function (RdsInstanceStatus) {
+    RdsInstanceStatus["RUNNING"] = "Running";
+    RdsInstanceStatus["CREATING"] = "Creating";
+    RdsInstanceStatus["DELETED"] = "Deleted";
+    RdsInstanceStatus["DELETE_FAILED"] = "DeleteFailed";
+    RdsInstanceStatus["RESTARTING"] = "Restarting";
+})(RdsInstanceStatus || (exports.RdsInstanceStatus = RdsInstanceStatus = {}));
+const waitForRdsInstanceReady = async (getInstance, instanceId) => {
+    const maxAttempts = 60;
+    let attempts = 0;
+    while (attempts < maxAttempts) {
+        const instance = await getInstance(instanceId);
+        if (!instance) {
+            throw new Error(lang_1.lang.__('RDS_INSTANCE_NOT_FOUND', { instanceId }));
+        }
+        if (instance.dbInstanceStatus === RdsInstanceStatus.RUNNING) {
+            logger_1.logger.info(lang_1.lang.__('RDS_INSTANCE_READY', { instanceId }));
+            return;
+        }
+        if (instance.dbInstanceStatus === RdsInstanceStatus.DELETED ||
+            instance.dbInstanceStatus === RdsInstanceStatus.DELETE_FAILED) {
+            throw new Error(lang_1.lang.__('RDS_INSTANCE_ERROR_STATE', { status: instance.dbInstanceStatus }));
+        }
+        logger_1.logger.info(lang_1.lang.__('RDS_INSTANCE_WAITING', {
+            instanceId,
+            status: instance.dbInstanceStatus ?? 'unknown',
+        }));
+        await new Promise((resolve) => setTimeout(resolve, 10000));
+        attempts++;
+    }
+    throw new Error(lang_1.lang.__('RDS_INSTANCE_TIMEOUT_READY', { instanceId }));
+};
+const createRdsOperations = (rdsClient, context) => {
+    const operations = {
+        createInstance: async (config) => {
+            const params = {
+                RegionId: context.region,
+                Engine: config.engine,
+                EngineVersion: config.engineVersion,
+                DBInstanceClass: config.dbInstanceClass,
+                DBInstanceStorage: config.dbInstanceStorage,
+                Category: config.category,
+                DBInstanceStorageType: config.dbInstanceStorageType,
+                DBInstanceDescription: config.dbInstanceDescription,
+                PayType: 'Serverless',
+                SecurityIPList: config.securityIPList || '0.0.0.0/0',
+                VpcId: config.vpcId,
+                VSwitchId: config.vSwitchId,
+                ZoneId: config.zoneId,
+                MasterUsername: config.masterUsername,
+                MasterUserPassword: config.masterUserPassword,
+                MasterUserType: config.masterUserType || 'Super',
+                ServerlessConfig: config.serverlessConfig
+                    ? {
+                        MinCapacity: config.serverlessConfig.minCapacity,
+                        MaxCapacity: config.serverlessConfig.maxCapacity,
+                        AutoPause: config.serverlessConfig.autoPause,
+                        SwitchForce: config.serverlessConfig.switchForce,
+                    }
+                    : undefined,
+                BurstingEnabled: config.burstingEnabled,
+            };
+            try {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const response = await rdsClient.createDBInstance(params);
+                logger_1.logger.info(lang_1.lang.__('RDS_INSTANCE_CREATION_INITIATED'));
+                if (!response.body?.DBInstanceId) {
+                    throw new Error(lang_1.lang.__('RDS_INSTANCE_NO_ID_RETURNED'));
+                }
+                const instanceId = response.body.DBInstanceId;
+                // Wait for instance to be ready
+                await waitForRdsInstanceReady(operations.getInstance, instanceId);
+                return instanceId;
+            }
+            catch (error) {
+                logger_1.logger.error(lang_1.lang.__('RDS_INSTANCE_CREATION_FAILED', { error: String(error) }));
+                throw error;
+            }
+        },
+        getInstance: async (instanceId) => {
+            const params = {
+                DBInstanceId: instanceId,
+            };
+            try {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const response = await rdsClient.describeDBInstanceAttribute(params);
+                if (!response.body?.Items?.DBInstanceAttribute ||
+                    response.body.Items.DBInstanceAttribute.length === 0) {
+                    return null;
+                }
+                const instance = response.body.Items.DBInstanceAttribute[0];
+                return {
+                    dbInstanceId: instance.DBInstanceId,
+                    dbInstanceDescription: instance.DBInstanceDescription,
+                    engine: instance.Engine,
+                    engineVersion: instance.EngineVersion,
+                    dbInstanceClass: instance.DBInstanceClass,
+                    dbInstanceStorage: instance.DBInstanceStorage,
+                    category: instance.Category,
+                    dbInstanceStorageType: instance.DBInstanceStorageType,
+                    serverlessConfig: instance.ServerlessConfig
+                        ? {
+                            minCapacity: instance.ServerlessConfig.MinCapacity,
+                            maxCapacity: instance.ServerlessConfig.MaxCapacity,
+                            autoPause: instance.ServerlessConfig.AutoPause,
+                            switchForce: instance.ServerlessConfig.SwitchForce,
+                        }
+                        : undefined,
+                    masterUsername: instance.MasterUsername,
+                    vpcId: instance.VpcId,
+                    vSwitchId: instance.VSwitchId,
+                    zoneId: instance.ZoneId,
+                    connectionString: instance.ConnectionString,
+                    port: instance.Port,
+                    dbInstanceStatus: instance.DBInstanceStatus,
+                    createTime: instance.CreateTime,
+                    regionId: instance.RegionId,
+                    securityIPList: instance.SecurityIPList,
+                    multiAZ: instance.MultiAZ === 'true',
+                };
+            }
+            catch (error) {
+                logger_1.logger.error(lang_1.lang.__('RDS_INSTANCE_GET_FAILED', { error: String(error) }));
+                return null;
+            }
+        },
+        updateInstance: async (instanceId, config) => {
+            try {
+                // Update serverless configuration
+                if (config.serverlessConfig) {
+                    const serverlessParams = {
+                        DBInstanceId: instanceId,
+                        ServerlessConfig: {
+                            MinCapacity: config.serverlessConfig.minCapacity,
+                            MaxCapacity: config.serverlessConfig.maxCapacity,
+                            AutoPause: config.serverlessConfig.autoPause,
+                            SwitchForce: config.serverlessConfig.switchForce,
+                        },
+                    };
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    await rdsClient.modifyDBInstanceSpec(serverlessParams);
+                }
+                // Update security IP list if provided
+                if (config.securityIPList) {
+                    const securityParams = {
+                        DBInstanceId: instanceId,
+                        SecurityIPList: config.securityIPList,
+                    };
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    await rdsClient.modifySecurityIps(securityParams);
+                }
+                logger_1.logger.info(lang_1.lang.__('RDS_INSTANCE_UPDATED', { instanceId }));
+                // Wait for instance to be ready
+                await waitForRdsInstanceReady(operations.getInstance, instanceId);
+            }
+            catch (error) {
+                logger_1.logger.error(lang_1.lang.__('RDS_INSTANCE_UPDATE_FAILED', { error: String(error) }));
+                throw error;
+            }
+        },
+        deleteInstance: async (instanceId) => {
+            const params = {
+                DBInstanceId: instanceId,
+            };
+            try {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                await rdsClient.deleteDBInstance(params);
+                logger_1.logger.info(lang_1.lang.__('RDS_INSTANCE_DELETION_INITIATED', { instanceId }));
+                // Wait for instance to be deleted
+                const maxAttempts = 60;
+                let attempts = 0;
+                while (attempts < maxAttempts) {
+                    const instance = await operations.getInstance(instanceId);
+                    if (!instance) {
+                        logger_1.logger.info(lang_1.lang.__('RDS_INSTANCE_DELETED', { instanceId }));
+                        return;
+                    }
+                    logger_1.logger.info(lang_1.lang.__('RDS_INSTANCE_WAITING_DELETE', { instanceId }));
+                    await new Promise((resolve) => setTimeout(resolve, 10000));
+                    attempts++;
+                }
+                throw new Error(lang_1.lang.__('RDS_INSTANCE_TIMEOUT_DELETE', { instanceId }));
+            }
+            catch (error) {
+                // If instance is not found, consider it deleted
+                if (error &&
+                    typeof error === 'object' &&
+                    'code' in error &&
+                    error.code === 'InvalidDBInstanceId.NotFound') {
+                    logger_1.logger.info(lang_1.lang.__('RDS_INSTANCE_DELETED', { instanceId }));
+                    return;
+                }
+                logger_1.logger.error(lang_1.lang.__('RDS_INSTANCE_DELETE_FAILED', { error: String(error) }));
+                throw error;
+            }
+        },
+    };
+    return operations;
+};
+exports.createRdsOperations = createRdsOperations;