@geek-fun/serverlessinsight 0.4.0 → 0.5.0

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

@@ -0,0 +1,270 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFc3Operations = void 0;
+const fc = __importStar(require("@alicloud/fc20230330"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const createFc3Operations = (fc3Client) => ({
+    createFunction: async (config, codePath) => {
+        const codeBuffer = node_fs_1.default.readFileSync(codePath);
+        const codeBase64 = codeBuffer.toString('base64');
+        const createFunctionInput = new fc.CreateFunctionInput({
+            functionName: config.functionName,
+            runtime: config.runtime,
+            handler: config.handler,
+            memorySize: config.memorySize,
+            timeout: config.timeout,
+            code: new fc.InputCodeLocation({
+                zipFile: codeBase64,
+            }),
+            ...(config.diskSize && { diskSize: config.diskSize }),
+            ...(config.environmentVariables && { environmentVariables: config.environmentVariables }),
+            ...(config.gpuConfig && {
+                gpuConfig: new fc.GPUConfig({
+                    gpuMemorySize: config.gpuConfig.gpuMemorySize,
+                    gpuType: config.gpuConfig.gpuType,
+                }),
+            }),
+            ...(config.vpcConfig && {
+                vpcConfig: new fc.VPCConfig({
+                    vpcId: config.vpcConfig.vpcId,
+                    vSwitchIds: config.vpcConfig.vSwitchIds,
+                    securityGroupId: config.vpcConfig.securityGroupId,
+                }),
+            }),
+            ...(config.nasConfig && {
+                nasConfig: new fc.NASConfig({
+                    userId: config.nasConfig.userId,
+                    groupId: config.nasConfig.groupId,
+                    mountPoints: config.nasConfig.mountPoints?.map((mp) => new fc.NASMountConfig({
+                        serverAddr: mp.serverAddr,
+                        mountDir: mp.mountDir,
+                        enableTLS: mp.enableTls,
+                    })),
+                }),
+            }),
+            ...(config.logConfig && {
+                logConfig: new fc.LogConfig({
+                    project: config.logConfig.project,
+                    logstore: config.logConfig.logstore,
+                    enableRequestMetrics: config.logConfig.enableRequestMetrics,
+                    enableInstanceMetrics: config.logConfig.enableInstanceMetrics,
+                    logBeginRule: config.logConfig.logBeginRule,
+                }),
+            }),
+            ...(config.customContainerConfig && {
+                customContainerConfig: new fc.CustomContainerConfig({
+                    image: config.customContainerConfig.image,
+                    entrypoint: config.customContainerConfig.entrypoint,
+                    command: config.customContainerConfig.command,
+                    port: config.customContainerConfig.port,
+                    accelerationType: config.customContainerConfig.accelerationType,
+                }),
+            }),
+            ...(config.description && { description: config.description }),
+            ...(config.internetAccess !== undefined && { internetAccess: config.internetAccess }),
+            ...(config.role && { role: config.role }),
+        });
+        const request = new fc.CreateFunctionRequest({
+            body: createFunctionInput,
+        });
+        await fc3Client.createFunction(request);
+    },
+    getFunction: async (functionName) => {
+        try {
+            const request = new fc.GetFunctionRequest({});
+            const response = await fc3Client.getFunction(functionName, request);
+            if (!response || !response.body) {
+                return null;
+            }
+            const body = response.body;
+            return {
+                functionName: body.functionName,
+                functionArn: body.functionArn,
+                functionId: body.functionId,
+                runtime: body.runtime,
+                handler: body.handler,
+                memorySize: body.memorySize,
+                timeout: body.timeout,
+                diskSize: body.diskSize,
+                cpu: body.cpu,
+                environmentVariables: body.environmentVariables,
+                vpcConfig: body.vpcConfig
+                    ? {
+                        vpcId: body.vpcConfig.vpcId,
+                        vSwitchIds: body.vpcConfig.vSwitchIds,
+                        securityGroupId: body.vpcConfig.securityGroupId,
+                    }
+                    : undefined,
+                gpuConfig: body.gpuConfig
+                    ? {
+                        gpuMemorySize: body.gpuConfig.gpuMemorySize,
+                        gpuType: body.gpuConfig.gpuType,
+                    }
+                    : undefined,
+                nasConfig: body.nasConfig
+                    ? {
+                        userId: body.nasConfig.userId,
+                        groupId: body.nasConfig.groupId,
+                        mountPoints: body.nasConfig.mountPoints?.map((mp) => ({
+                            serverAddr: mp.serverAddr,
+                            mountDir: mp.mountDir,
+                            enableTls: mp.enableTLS,
+                        })),
+                    }
+                    : undefined,
+                logConfig: body.logConfig
+                    ? {
+                        project: body.logConfig.project,
+                        logstore: body.logConfig.logstore,
+                        enableRequestMetrics: body.logConfig.enableRequestMetrics,
+                        enableInstanceMetrics: body.logConfig.enableInstanceMetrics,
+                        logBeginRule: body.logConfig.logBeginRule,
+                    }
+                    : undefined,
+                customContainerConfig: body.customContainerConfig
+                    ? {
+                        image: body.customContainerConfig.image,
+                        entrypoint: body.customContainerConfig.entrypoint,
+                        command: body.customContainerConfig.command,
+                        port: body.customContainerConfig.port,
+                        accelerationType: body.customContainerConfig.accelerationType,
+                    }
+                    : undefined,
+                description: body.description,
+                internetAccess: body.internetAccess,
+                role: body.role,
+                codeChecksum: body.codeChecksum,
+                codeSize: body.codeSize,
+                createdTime: body.createdTime,
+                lastModifiedTime: body.lastModifiedTime,
+                state: body.state,
+                stateReason: body.stateReason,
+                stateReasonCode: body.stateReasonCode,
+                lastUpdateStatus: body.lastUpdateStatus,
+                lastUpdateStatusReason: body.lastUpdateStatusReason,
+                lastUpdateStatusReasonCode: body.lastUpdateStatusReasonCode,
+            };
+        }
+        catch (error) {
+            if (error &&
+                typeof error === 'object' &&
+                'code' in error &&
+                error.code === 'FunctionNotFound') {
+                return null;
+            }
+            throw error;
+        }
+    },
+    updateFunctionConfiguration: async (config) => {
+        const updateFunctionInput = new fc.UpdateFunctionInput({
+            runtime: config.runtime,
+            handler: config.handler,
+            memorySize: config.memorySize,
+            timeout: config.timeout,
+            ...(config.diskSize && { diskSize: config.diskSize }),
+            ...(config.environmentVariables && { environmentVariables: config.environmentVariables }),
+            ...(config.gpuConfig && {
+                gpuConfig: new fc.GPUConfig({
+                    gpuMemorySize: config.gpuConfig.gpuMemorySize,
+                    gpuType: config.gpuConfig.gpuType,
+                }),
+            }),
+            ...(config.vpcConfig && {
+                vpcConfig: new fc.VPCConfig({
+                    vpcId: config.vpcConfig.vpcId,
+                    vSwitchIds: config.vpcConfig.vSwitchIds,
+                    securityGroupId: config.vpcConfig.securityGroupId,
+                }),
+            }),
+            ...(config.nasConfig && {
+                nasConfig: new fc.NASConfig({
+                    userId: config.nasConfig.userId,
+                    groupId: config.nasConfig.groupId,
+                    mountPoints: config.nasConfig.mountPoints?.map((mp) => new fc.NASMountConfig({
+                        serverAddr: mp.serverAddr,
+                        mountDir: mp.mountDir,
+                        enableTLS: mp.enableTls,
+                    })),
+                }),
+            }),
+            ...(config.logConfig && {
+                logConfig: new fc.LogConfig({
+                    project: config.logConfig.project,
+                    logstore: config.logConfig.logstore,
+                    enableRequestMetrics: config.logConfig.enableRequestMetrics,
+                    enableInstanceMetrics: config.logConfig.enableInstanceMetrics,
+                    logBeginRule: config.logConfig.logBeginRule,
+                }),
+            }),
+            ...(config.customContainerConfig && {
+                customContainerConfig: new fc.CustomContainerConfig({
+                    image: config.customContainerConfig.image,
+                    entrypoint: config.customContainerConfig.entrypoint,
+                    command: config.customContainerConfig.command,
+                    port: config.customContainerConfig.port,
+                    accelerationType: config.customContainerConfig.accelerationType,
+                }),
+            }),
+            ...(config.description && { description: config.description }),
+            ...(config.internetAccess !== undefined && { internetAccess: config.internetAccess }),
+            ...(config.role && { role: config.role }),
+        });
+        const request = new fc.UpdateFunctionRequest({
+            body: updateFunctionInput,
+        });
+        await fc3Client.updateFunction(config.functionName, request);
+    },
+    updateFunctionCode: async (functionName, codePath) => {
+        const codeBuffer = node_fs_1.default.readFileSync(codePath);
+        const codeBase64 = codeBuffer.toString('base64');
+        const updateFunctionInput = new fc.UpdateFunctionInput({
+            code: new fc.InputCodeLocation({
+                zipFile: codeBase64,
+            }),
+        });
+        const request = new fc.UpdateFunctionRequest({
+            body: updateFunctionInput,
+        });
+        await fc3Client.updateFunction(functionName, request);
+    },
+    deleteFunction: async (functionName) => {
+        await fc3Client.deleteFunction(functionName);
+    },
+});
+exports.createFc3Operations = createFc3Operations;

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

@@ -0,0 +1,141 @@
+"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.createAliyunClient = void 0;
+const fc20230330_1 = __importDefault(require("@alicloud/fc20230330"));
+const sls20201230_1 = __importDefault(require("@alicloud/sls20201230"));
+const ram20150501_1 = __importDefault(require("@alicloud/ram20150501"));
+const ecs20140526_1 = __importDefault(require("@alicloud/ecs20140526"));
+const nas20170626_1 = __importDefault(require("@alicloud/nas20170626"));
+const cloudapi20160714_1 = __importDefault(require("@alicloud/cloudapi20160714"));
+const rds20140815_1 = __importDefault(require("@alicloud/rds20140815"));
+const es_serverless20230627_1 = __importDefault(require("@alicloud/es-serverless20230627"));
+const alidns20150109_1 = __importDefault(require("@alicloud/alidns20150109"));
+const $OpenApi = __importStar(require("@alicloud/openapi-client"));
+const ali_oss_1 = __importDefault(require("ali-oss"));
+const fc3Operations_1 = require("./fc3Operations");
+const slsOperations_1 = require("./slsOperations");
+const ramOperations_1 = require("./ramOperations");
+const ecsOperations_1 = require("./ecsOperations");
+const nasOperations_1 = require("./nasOperations");
+const apigwOperations_1 = require("./apigwOperations");
+const ossOperations_1 = require("./ossOperations");
+const rdsOperations_1 = require("./rdsOperations");
+const esOperations_1 = require("./esOperations");
+const tablestoreOperations_1 = require("./tablestoreOperations");
+const dnsOperations_1 = require("./dnsOperations");
+__exportStar(require("./types"), exports);
+__exportStar(require("./apigwOperations"), exports);
+__exportStar(require("./ossOperations"), exports);
+__exportStar(require("./rdsOperations"), exports);
+__exportStar(require("./esOperations"), exports);
+__exportStar(require("./tablestoreOperations"), exports);
+__exportStar(require("./dnsOperations"), exports);
+const initializeSdkClients = (context) => {
+    const baseConfig = {
+        accessKeyId: context.accessKeyId,
+        accessKeySecret: context.accessKeySecret,
+        regionId: context.region,
+        securityToken: context.securityToken,
+    };
+    const fc3Config = new $OpenApi.Config(baseConfig);
+    fc3Config.endpoint = `${context.accountId}.${context.region}.fc.aliyuncs.com`;
+    const fc3Client = new fc20230330_1.default(fc3Config);
+    const slsConfig = new $OpenApi.Config(baseConfig);
+    slsConfig.endpoint = `${context.region}.log.aliyuncs.com`;
+    const slsClient = new sls20201230_1.default(slsConfig);
+    const ramConfig = new $OpenApi.Config(baseConfig);
+    ramConfig.endpoint = 'ram.aliyuncs.com';
+    const ramClient = new ram20150501_1.default(ramConfig);
+    const ecsConfig = new $OpenApi.Config(baseConfig);
+    ecsConfig.endpoint = `ecs.${context.region}.aliyuncs.com`;
+    const ecsClient = new ecs20140526_1.default(ecsConfig);
+    const nasConfig = new $OpenApi.Config(baseConfig);
+    nasConfig.endpoint = `nas.${context.region}.aliyuncs.com`;
+    const nasClient = new nas20170626_1.default(nasConfig);
+    const ossClient = new ali_oss_1.default({
+        accessKeyId: context.accessKeyId,
+        accessKeySecret: context.accessKeySecret,
+        region: `oss-${context.region}`,
+        stsToken: context.securityToken,
+    });
+    const apigwConfig = new $OpenApi.Config(baseConfig);
+    apigwConfig.endpoint = `apigateway.${context.region}.aliyuncs.com`;
+    const apigwClient = new cloudapi20160714_1.default(apigwConfig);
+    const rdsConfig = new $OpenApi.Config(baseConfig);
+    rdsConfig.endpoint = `rds.aliyuncs.com`;
+    const rdsClient = new rds20140815_1.default(rdsConfig);
+    const esConfig = new $OpenApi.Config(baseConfig);
+    esConfig.endpoint = `elasticsearch-serverless.${context.region}.aliyuncs.com`;
+    const esClient = new es_serverless20230627_1.default(esConfig);
+    const dnsConfig = new $OpenApi.Config(baseConfig);
+    dnsConfig.endpoint = `alidns.aliyuncs.com`;
+    const dnsClient = new alidns20150109_1.default(dnsConfig);
+    return {
+        fc3: fc3Client,
+        sls: slsClient,
+        ram: ramClient,
+        ecs: ecsClient,
+        nas: nasClient,
+        oss: ossClient,
+        apigw: apigwClient,
+        rds: rdsClient,
+        es: esClient,
+        dns: dnsClient,
+    };
+};
+const createAliyunClient = (context) => {
+    const sdkClients = initializeSdkClients(context);
+    return {
+        fc3: (0, fc3Operations_1.createFc3Operations)(sdkClients.fc3),
+        sls: (0, slsOperations_1.createSlsOperations)(sdkClients.sls),
+        ram: (0, ramOperations_1.createRamOperations)(sdkClients.ram),
+        ecs: (0, ecsOperations_1.createEcsOperations)(sdkClients.ecs, context),
+        nas: (0, nasOperations_1.createNasOperations)(sdkClients.nas),
+        oss: (0, ossOperations_1.createOssOperations)(sdkClients.oss, context.region),
+        apigw: (0, apigwOperations_1.createApigwOperations)(sdkClients.apigw, sdkClients.dns, context),
+        rds: (0, rdsOperations_1.createRdsOperations)(sdkClients.rds, context),
+        es: (0, esOperations_1.createEsOperations)(sdkClients.es, context),
+        dns: (0, dnsOperations_1.createDnsOperations)(sdkClients.dns),
+        tablestore: (instanceName) => (0, tablestoreOperations_1.createTablestoreOperations)(`https://${instanceName}.${context.region}.ots.aliyuncs.com`, instanceName, context),
+    };
+};
+exports.createAliyunClient = createAliyunClient;

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

@@ -0,0 +1,233 @@
+"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.createNasOperations = void 0;
+const nas = __importStar(require("@alicloud/nas20170626"));
+const types_1 = require("../../types");
+const storageClassMap = {
+    [types_1.NasStorageClassEnum.STANDARD_CAPACITY]: { fileSystemType: 'standard', storageType: 'Capacity' },
+    [types_1.NasStorageClassEnum.STANDARD_PERFORMANCE]: {
+        fileSystemType: 'standard',
+        storageType: 'Performance',
+    },
+    [types_1.NasStorageClassEnum.EXTREME_STANDARD]: { fileSystemType: 'extreme', storageType: 'standard' },
+    [types_1.NasStorageClassEnum.EXTREME_ADVANCE]: { fileSystemType: 'extreme', storageType: 'advance' },
+};
+const createNasOperations = (nasClient) => {
+    const operations = {
+        createAccessGroup: async (accessGroupName, accessGroupType = 'Vpc') => {
+            const request = new nas.CreateAccessGroupRequest({
+                accessGroupName,
+                accessGroupType,
+            });
+            await nasClient.createAccessGroup(request);
+            return {
+                accessGroupName,
+                accessGroupType,
+            };
+        },
+        getAccessGroup: async (accessGroupName) => {
+            try {
+                const request = new nas.DescribeAccessGroupsRequest({
+                    accessGroupName,
+                });
+                const response = await nasClient.describeAccessGroups(request);
+                if (!response ||
+                    !response.body ||
+                    !response.body.accessGroups ||
+                    !response.body.accessGroups.accessGroup ||
+                    response.body.accessGroups.accessGroup.length === 0) {
+                    return null;
+                }
+                const ag = response.body.accessGroups.accessGroup[0];
+                return {
+                    accessGroupName: ag.accessGroupName ?? accessGroupName,
+                    accessGroupType: ag.accessGroupType,
+                    ruleCount: ag.ruleCount,
+                };
+            }
+            catch {
+                return null;
+            }
+        },
+        deleteAccessGroup: async (accessGroupName) => {
+            const request = new nas.DeleteAccessGroupRequest({
+                accessGroupName,
+            });
+            await nasClient.deleteAccessGroup(request);
+        },
+        createAccessRule: async (accessGroupName, sourceCidrIp) => {
+            const request = new nas.CreateAccessRuleRequest({
+                accessGroupName,
+                sourceCidrIp,
+                RWAccessType: 'RDWR',
+                userAccessType: 'no_squash',
+                priority: 1,
+            });
+            await nasClient.createAccessRule(request);
+        },
+        createFileSystem: async (storageClass, functionName) => {
+            const { fileSystemType, storageType } = storageClassMap[storageClass];
+            const request = new nas.CreateFileSystemRequest({
+                fileSystemType,
+                storageType,
+                protocolType: 'NFS',
+                description: `ServerlessInsight NAS for ${functionName}`,
+            });
+            const response = await nasClient.createFileSystem(request);
+            const fileSystemId = response.body?.fileSystemId;
+            if (!fileSystemId) {
+                throw new Error('Failed to create NAS file system');
+            }
+            // Wait for file system to be ready
+            let retries = 0;
+            while (retries < 30) {
+                const fs = await operations.getFileSystem(fileSystemId);
+                if (fs && fs.status === 'Running') {
+                    return fs;
+                }
+                await new Promise((resolve) => setTimeout(resolve, 5000));
+                retries++;
+            }
+            return {
+                fileSystemId,
+                fileSystemType,
+                storageType,
+                protocolType: 'NFS',
+            };
+        },
+        getFileSystem: async (fileSystemId) => {
+            try {
+                const request = new nas.DescribeFileSystemsRequest({
+                    fileSystemId,
+                });
+                const response = await nasClient.describeFileSystems(request);
+                if (!response ||
+                    !response.body ||
+                    !response.body.fileSystems ||
+                    !response.body.fileSystems.fileSystem ||
+                    response.body.fileSystems.fileSystem.length === 0) {
+                    return null;
+                }
+                const fs = response.body.fileSystems.fileSystem[0];
+                return {
+                    fileSystemId: fs.fileSystemId ?? fileSystemId,
+                    fileSystemType: fs.fileSystemType,
+                    storageType: fs.storageType,
+                    protocolType: fs.protocolType,
+                    status: fs.status,
+                    createTime: fs.createTime,
+                };
+            }
+            catch {
+                return null;
+            }
+        },
+        deleteFileSystem: async (fileSystemId) => {
+            const request = new nas.DeleteFileSystemRequest({
+                fileSystemId,
+            });
+            await nasClient.deleteFileSystem(request);
+        },
+        createMountTarget: async (fileSystemId, accessGroupName, vpcId, vSwitchId) => {
+            const request = new nas.CreateMountTargetRequest({
+                fileSystemId,
+                accessGroupName,
+                networkType: 'Vpc',
+                vpcId,
+                vSwitchId,
+            });
+            const response = await nasClient.createMountTarget(request);
+            const mountTargetDomain = response.body?.mountTargetDomain;
+            if (!mountTargetDomain) {
+                throw new Error('Failed to create NAS mount target');
+            }
+            // Wait for mount target to be ready
+            let retries = 0;
+            while (retries < 30) {
+                const mt = await operations.getMountTarget(fileSystemId, mountTargetDomain);
+                if (mt && mt.status === 'Active') {
+                    return mt;
+                }
+                await new Promise((resolve) => setTimeout(resolve, 5000));
+                retries++;
+            }
+            return {
+                mountTargetDomain,
+                fileSystemId,
+                vpcId,
+                vSwitchId,
+                accessGroupName,
+            };
+        },
+        getMountTarget: async (fileSystemId, mountTargetDomain) => {
+            try {
+                const request = new nas.DescribeMountTargetsRequest({
+                    fileSystemId,
+                    mountTargetDomain,
+                });
+                const response = await nasClient.describeMountTargets(request);
+                if (!response ||
+                    !response.body ||
+                    !response.body.mountTargets ||
+                    !response.body.mountTargets.mountTarget ||
+                    response.body.mountTargets.mountTarget.length === 0) {
+                    return null;
+                }
+                const mt = response.body.mountTargets.mountTarget[0];
+                return {
+                    mountTargetDomain: mt.mountTargetDomain ?? mountTargetDomain,
+                    fileSystemId,
+                    vpcId: mt.vpcId,
+                    vSwitchId: mt.vswId,
+                    accessGroupName: mt.accessGroup,
+                    status: mt.status,
+                };
+            }
+            catch {
+                return null;
+            }
+        },
+        deleteMountTarget: async (fileSystemId, mountTargetDomain) => {
+            const request = new nas.DeleteMountTargetRequest({
+                fileSystemId,
+                mountTargetDomain,
+            });
+            await nasClient.deleteMountTarget(request);
+        },
+    };
+    return operations;
+};
+exports.createNasOperations = createNasOperations;