@geek-fun/serverlessinsight 0.2.1 → 0.3.1

package/dist/src/stack/rosStack/event.js

@@ -39,15 +39,18 @@ const ram = __importStar(require("@alicloud/ros-cdk-ram"));
 const common_1 = require("../../common");
 const agw = __importStar(require("@alicloud/ros-cdk-apigateway"));
 const lodash_1 = require("lodash");
+const dns = __importStar(require("@alicloud/ros-cdk-dns"));
 const resolveEvents = (scope, events, tags, context, service) => {
     if ((0, lodash_1.isEmpty)(events)) {
         return undefined;
     }
     const apiGateway = events.filter((event) => event.type === types_1.EventTypes.API_GATEWAY);
-    if (apiGateway?.length) {
-        const gatewayAccessRole = new ram.RosRole(scope, (0, common_1.replaceReference)(`${service}_role`, context), {
-            roleName: (0, common_1.replaceReference)(`${service}-gateway-access-role`, context),
-            description: (0, common_1.replaceReference)(`${service} role`, context),
+    if (!apiGateway?.length)
+        return;
+    apiGateway.forEach((event) => {
+        const gatewayAccessRole = new ram.RosRole(scope, (0, common_1.formatRosId)(`${event.key}_agw_role`), {
+            roleName: (0, common_1.calcRefs)(`${event.name}-agw-access-role`, context),
+            description: (0, common_1.calcRefs)(`${service} role`, context),
             assumeRolePolicyDocument: {
                 version: '1',
                 statement: [
@@ -62,7 +65,7 @@ const resolveEvents = (scope, events, tags, context, service) => {
             },
             policies: [
                 {
-                    policyName: (0, common_1.replaceReference)(`${service}-policy`, context),
+                    policyName: (0, common_1.calcRefs)(`${service}-${event.name}-policy`, context),
                     policyDocument: {
                         version: '1',
                         statement: [
@@ -77,60 +80,64 @@ const resolveEvents = (scope, events, tags, context, service) => {
                 },
             ],
         }, true);
-        const apiGatewayGroup = new agw.RosGroup(scope, (0, common_1.replaceReference)(`${service}_apigroup`, context), {
-            groupName: (0, common_1.replaceReference)(`${service}_apigroup`, context),
-            tags: (0, common_1.replaceReference)(tags, context),
+        const apiGatewayGroup = new agw.RosGroup(scope, (0, common_1.formatRosId)(`${event.key}_agw_group`), {
+            groupName: (0, common_1.calcRefs)(`${service}-agw-group`, context),
+            tags: (0, common_1.calcRefs)(tags, context),
             passthroughHeaders: 'host',
         }, true);
-        // new agw.RosCustomDomain(
-        //   this,
-        //   'customDomain',
-        //   {
-        //     domainName: 'example.com',
-        //     certificateName: 'example.com',
-        //     certificateBody: 'example.com',
-        //     certificatePrivateKey: 'example.com',
-        //     groupId: apiGatewayGroup.attrGroupId,
-        //   },
-        //   true,
-        // );
-        apiGateway.forEach((event) => {
-            event.triggers.forEach((trigger) => {
-                const key = (0, common_1.encodeBase64)((0, common_1.replaceReference)(`${trigger.method}_${trigger.path}`, context)).replace(/=+$/, '');
-                const api = new agw.RosApi(scope, `${event.key}_api_${key}`, {
-                    apiName: (0, common_1.replaceReference)(`${event.name}_api_${key}`, context),
-                    groupId: apiGatewayGroup.attrGroupId,
-                    visibility: 'PRIVATE',
-                    authType: 'ANONYMOUS',
-                    requestConfig: {
-                        requestProtocol: 'HTTP',
-                        requestHttpMethod: (0, common_1.replaceReference)(trigger.method, context),
-                        requestPath: (0, common_1.replaceReference)(trigger.path, context),
-                        requestMode: 'PASSTHROUGH',
-                    },
-                    serviceConfig: {
-                        serviceProtocol: 'FunctionCompute',
-                        functionComputeConfig: {
-                            fcRegionId: context.region,
-                            functionName: (0, common_1.replaceReference)(trigger.backend, context),
-                            roleArn: gatewayAccessRole.attrArn,
-                            fcVersion: '3.0',
-                            method: (0, common_1.replaceReference)(trigger.method, context),
-                        },
+        if (event.domain) {
+            const dnsRecordId = (0, common_1.formatRosId)(`${event.key}_agw_custom_domain_record`);
+            const { domainName, rr } = (0, common_1.splitDomain)(event.domain?.domain_name);
+            new dns.DomainRecord(scope, dnsRecordId, {
+                domainName,
+                rr,
+                type: 'CNAME',
+                value: apiGatewayGroup.attrSubDomain,
+            });
+            const agwCustomDomain = new agw.RosCustomDomain(scope, (0, common_1.formatRosId)(`${event.key}_agw_custom_domain`), {
+                groupId: apiGatewayGroup.attrGroupId,
+                domainName: event.domain.domain_name,
+                certificateName: event.domain.certificate_name,
+                certificateBody: event.domain.certificate_body,
+                certificatePrivateKey: event.domain.certificate_private_key,
+            }, true);
+            agwCustomDomain.addRosDependency(dnsRecordId);
+        }
+        event.triggers.forEach((trigger) => {
+            const key = (0, common_1.formatRosId)((0, common_1.calcValue)(`${trigger.method}_${trigger.path}`, context));
+            const api = new agw.RosApi(scope, (0, common_1.formatRosId)(`${event.key}_agw_api_${key}`), {
+                apiName: (0, common_1.calcRefs)(`${event.name}-agw-api-${key.replace(/_/g, '-')}`, context),
+                groupId: apiGatewayGroup.attrGroupId,
+                visibility: 'PRIVATE',
+                authType: 'ANONYMOUS',
+                requestConfig: {
+                    requestProtocol: 'HTTP',
+                    requestHttpMethod: (0, common_1.calcRefs)(trigger.method, context),
+                    requestPath: (0, common_1.calcRefs)(trigger.path, context),
+                    requestMode: 'PASSTHROUGH',
+                },
+                serviceConfig: {
+                    serviceProtocol: 'FunctionCompute',
+                    functionComputeConfig: {
+                        fcRegionId: context.region,
+                        functionName: (0, common_1.calcRefs)(trigger.backend, context),
+                        roleArn: gatewayAccessRole.attrArn,
+                        fcVersion: '3.0',
+                        method: (0, common_1.calcRefs)(trigger.method, context),
                     },
-                    resultSample: 'ServerlessInsight resultSample',
-                    resultType: 'PASSTHROUGH',
-                    tags: (0, common_1.replaceReference)(tags, context),
-                }, true);
-                api.addDependsOn(apiGatewayGroup);
-                new agw.Deployment(scope, `${service}_deployment`, {
-                    apiId: api.attrApiId,
-                    groupId: apiGatewayGroup.attrGroupId,
-                    stageName: 'RELEASE',
-                    description: `${service} Api Gateway deployment`,
-                });
+                },
+                resultSample: 'ServerlessInsight resultSample',
+                resultType: 'PASSTHROUGH',
+                tags: (0, common_1.calcRefs)(tags, context),
+            }, true);
+            api.addDependsOn(apiGatewayGroup);
+            new agw.Deployment(scope, (0, common_1.formatRosId)(`${event.key}_agw_api_deployment_${key}`), {
+                apiId: api.attrApiId,
+                groupId: apiGatewayGroup.attrGroupId,
+                stageName: 'RELEASE',
+                description: (0, common_1.calcRefs)(`${service} Api Gateway deployment for api: ${trigger.method} ${trigger.path}`, context),
             });
         });
-    }
+    });
 };
 exports.resolveEvents = resolveEvents;

package/dist/src/stack/rosStack/function.js

@@ -34,26 +34,79 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveFunctions = void 0;
+const types_1 = require("../../types");
 const common_1 = require("../../common");
 const fc = __importStar(require("@alicloud/ros-cdk-fc3"));
 const lodash_1 = require("lodash");
 const ossDeployment = __importStar(require("@alicloud/ros-cdk-ossdeployment"));
 const ros = __importStar(require("@alicloud/ros-cdk-core"));
 const sls = __importStar(require("@alicloud/ros-cdk-sls"));
+const nas = __importStar(require("@alicloud/ros-cdk-nas"));
+const ecs = __importStar(require("@alicloud/ros-cdk-ecs"));
+const vpc = __importStar(require("@alicloud/ros-cdk-vpc"));
+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 securityGroupRangeMap = {
+    TCP: '1/65535',
+    UDP: '1/65535',
+    ICMP: '-1/-1',
+    GRE: '-1/-1',
+    ALL: '-1/-1',
+};
+const gpuConfigMap = {
+    [types_1.FunctionGpuEnum.TESLA_8]: { gpuMemorySize: 8192, gpuType: 'fc.gpu.tesla.1' },
+    [types_1.FunctionGpuEnum.TESLA_12]: { gpuMemorySize: 12288, gpuType: 'fc.gpu.tesla.1' },
+    [types_1.FunctionGpuEnum.TESLA_16]: { gpuMemorySize: 16384, gpuType: 'fc.gpu.tesla.1' },
+    [types_1.FunctionGpuEnum.AMPERE_8]: { gpuMemorySize: 8192, gpuType: 'fc.gpu.ampere.1' },
+    [types_1.FunctionGpuEnum.AMPERE_12]: { gpuMemorySize: 12288, gpuType: 'fc.gpu.ampere.1' },
+    [types_1.FunctionGpuEnum.AMPERE_16]: { gpuMemorySize: 16384, gpuType: 'fc.gpu.ampere.1' },
+    [types_1.FunctionGpuEnum.AMPERE_24]: { gpuMemorySize: 24576, gpuType: 'fc.gpu.ampere.1' },
+    [types_1.FunctionGpuEnum.ADA_48]: { gpuMemorySize: 49152, gpuType: 'fc.gpu.ada.1' },
+};
+const transformSecurityRules = (rules, ruleType) => {
+    return rules.map((rule) => {
+        const [protocol, cidrIp, portRange] = rule.split(':');
+        return {
+            ipProtocol: protocol.toLowerCase(),
+            portRange: portRange.toUpperCase() === 'ALL'
+                ? securityGroupRangeMap[protocol.toUpperCase()]
+                : portRange.includes('/')
+                    ? portRange
+                    : `${portRange}/${portRange}`,
+            [ruleType === 'INGRESS' ? 'sourceCidrIp' : 'destCidrIp']: cidrIp,
+        };
+    });
+};
+const transformGpuConfig = (gpu) => {
+    if (!gpu) {
+        return undefined;
+    }
+    return gpuConfigMap[gpu];
+};
 const resolveFunctions = (scope, functions, tags, context, service) => {
     if ((0, lodash_1.isEmpty)(functions)) {
         return undefined;
     }
     let logConfig = undefined;
     const enableLog = functions?.some(({ log }) => log);
-    const slsService = new sls.Project(scope, `${service}_sls`, { name: `${service}-sls`, tags: (0, common_1.replaceReference)(tags, context) }, true);
-    const slsLogstore = new sls.Logstore(scope, `${service}_sls_logstore`, {
-        logstoreName: `${service}-sls-logstore`,
-        projectName: slsService.attrName,
+    const slsProjectId = 'sls_project';
+    const slsLogstoreId = 'sls_logstore';
+    const slsIndexId = 'sls_index';
+    const slsProject = new sls.Project(scope, slsProjectId, { name: (0, common_1.calcRefs)(`${service}-sls`, context), tags: (0, common_1.calcRefs)(tags, context) }, true);
+    const slsLogstore = new sls.Logstore(scope, slsLogstoreId, {
+        logstoreName: (0, common_1.calcRefs)(`${service}-sls-logstore`, context),
+        projectName: slsProject.attrName,
         ttl: 7,
     }, true);
-    new sls.Index(scope, `${service}_sls_index`, {
-        projectName: slsService.attrName,
+    new sls.Index(scope, slsIndexId, {
+        projectName: slsProject.attrName,
         logstoreName: slsLogstore.attrLogstoreName,
         fullTextIndex: { enable: true },
     }, true);
@@ -65,50 +118,142 @@ const resolveFunctions = (scope, functions, tags, context, service) => {
         };
     }
     const fileSources = functions
-        ?.filter(({ code }) => (0, common_1.readCodeSize)(code) > common_1.CODE_ZIP_SIZE_LIMIT)
+        ?.filter(({ code }) => code?.path && (0, common_1.readCodeSize)(code.path) > common_1.CODE_ZIP_SIZE_LIMIT)
         .map(({ code, name }) => {
-        const fcName = (0, common_1.replaceReference)(name, context);
-        return { fcName, ...(0, common_1.getFileSource)(fcName, code) };
+        const fcName = (0, common_1.calcRefs)(name, context);
+        return { fcName, ...(0, common_1.getFileSource)(fcName, code.path) };
     });
     const destinationBucketName = ros.Fn.sub('si-bootstrap-artifacts-${ALIYUN::AccountId}-${ALIYUN::Region}');
-    const ossDeploymentId = `${service}_artifacts_code_deployment`;
+    const ossDeploymentId = 'si_auto_artifacts_code_deployment';
     if (!(0, lodash_1.isEmpty)(fileSources)) {
         new ossDeployment.BucketDeployment(scope, ossDeploymentId, {
             sources: fileSources.map(({ source }) => source),
             destinationBucket: destinationBucketName,
-            timeout: 3000,
+            timeout: common_1.OSS_DEPLOYMENT_TIMEOUT,
             logMonitoring: false,
             retainOnCreate: false,
         }, true);
     }
     functions?.forEach((fnc) => {
-        const storeInBucket = (0, common_1.readCodeSize)(fnc.code) > common_1.CODE_ZIP_SIZE_LIMIT;
-        let code = {
-            zipFile: (0, common_1.resolveCode)(fnc.code),
-        };
-        if (storeInBucket) {
-            code = {
-                ossBucketName: destinationBucketName,
-                ossObjectName: fileSources?.find(({ fcName }) => fcName === (0, common_1.replaceReference)(fnc.name, context))?.objectKey,
+        let runtimeConfig;
+        const storeInBucket = !!fnc.code?.path && (0, common_1.readCodeSize)((0, common_1.calcValue)(fnc.code.path, context)) > common_1.CODE_ZIP_SIZE_LIMIT;
+        if (fnc.container) {
+            runtimeConfig = {
+                runtime: 'custom-container',
+                handler: 'index.handler',
+                customContainerConfig: {
+                    image: (0, common_1.calcRefs)(fnc.container.image, context),
+                    command: (0, common_1.calcRefs)(fnc.container.cmd, context)?.split(' '),
+                    port: (0, common_1.calcRefs)(fnc.container.port, context),
+                },
+            };
+        }
+        else {
+            let code = {
+                zipFile: (0, common_1.resolveCode)((0, common_1.calcValue)(fnc.code.path, context)),
+            };
+            if (storeInBucket) {
+                code = {
+                    ossBucketName: destinationBucketName,
+                    ossObjectName: fileSources?.find(({ fcName }) => fcName === (0, common_1.calcRefs)(fnc.name, context))
+                        ?.objectKey,
+                };
+            }
+            runtimeConfig = {
+                code,
+                handler: (0, common_1.calcRefs)(fnc.code.handler, context),
+                runtime: (0, common_1.calcRefs)(fnc.code.runtime, context),
             };
         }
+        let vpcConfig = undefined;
+        if (fnc.network) {
+            const securityGroup = new ecs.SecurityGroup(scope, (0, common_1.formatRosId)(`${fnc.key}_security_group`), {
+                securityGroupName: fnc.network.security_group.name,
+                vpcId: (0, common_1.calcRefs)(fnc.network.vpc_id, context),
+                tags: (0, common_1.calcRefs)(tags, context),
+                securityGroupIngress: transformSecurityRules(fnc.network.security_group.ingress, 'INGRESS'),
+                securityGroupEgress: transformSecurityRules(fnc.network.security_group.egress, 'EGRESS'),
+            }, true);
+            vpcConfig = {
+                vpcId: (0, common_1.calcRefs)(fnc.network.vpc_id, context),
+                vSwitchIds: (0, common_1.calcRefs)(fnc.network.subnet_ids, context),
+                securityGroupId: securityGroup.attrSecurityGroupId,
+            };
+        }
+        let fcNas;
+        if (fnc.storage?.nas) {
+            fcNas = fnc.storage.nas.map((nasItem) => {
+                const storageClass = (0, common_1.calcValue)(nasItem.storage_class, context);
+                const { fileSystemType, storageType } = storageClassMap[storageClass];
+                const mountPathValue = (0, common_1.formatRosId)((0, common_1.calcValue)(nasItem.mount_path, context));
+                const nasMountTargetId = (0, common_1.formatRosId)(`${fnc.key}_nas_mount_${mountPathValue}`);
+                const accessGroup = new nas.AccessGroup(scope, (0, common_1.formatRosId)(`${fnc.key}_nas_access_${mountPathValue}`), {
+                    accessGroupName: (0, common_1.calcRefs)(`${fnc.name}-nas-access-${mountPathValue.replace(/_/g, '-')}`, context),
+                    accessGroupType: 'Vpc',
+                }, true);
+                const fcVpcSubnets = fnc.network?.subnet_ids.map((subnet) => new vpc.datasource.VSwitch(scope, (0, common_1.formatRosId)((0, common_1.calcValue)(`${fnc.key}_datasource_subnet_${subnet}`, context)), {
+                    vSwitchId: subnet,
+                    refreshOptions: 'Always',
+                }));
+                fcVpcSubnets?.forEach((subnetDatasource, index) => {
+                    new nas.AccessRule(scope, (0, common_1.formatRosId)((0, common_1.calcValue)(`${fnc.key}_nas_rule_${fnc.network.subnet_ids[index]}`, context)), {
+                        accessGroupName: accessGroup.attrAccessGroupName,
+                        sourceCidrIp: subnetDatasource.attrCidrBlock,
+                    }, true);
+                });
+                const nasResource = new nas.FileSystem(scope, (0, common_1.formatRosId)(`${fnc.key}_nas_${mountPathValue}`), {
+                    fileSystemType,
+                    storageType,
+                    protocolType: 'NFS',
+                    tags: [
+                        ...((0, common_1.calcRefs)(tags, context) ?? []),
+                        { key: 'function-name', value: (0, common_1.calcRefs)(fnc.name, context) },
+                    ],
+                }, true);
+                const nasMountTarget = new nas.MountTarget(scope, nasMountTargetId, {
+                    fileSystemId: nasResource.attrFileSystemId,
+                    networkType: 'Vpc',
+                    accessGroupName: accessGroup.attrAccessGroupName,
+                    vpcId: (0, common_1.calcRefs)(fnc.network.vpc_id, context),
+                    vSwitchId: (0, common_1.calcRefs)(fnc.network.subnet_ids[0], context),
+                }, true);
+                return {
+                    nas: nasResource,
+                    nasMount: nasMountTarget,
+                    mountDir: (0, common_1.calcRefs)(nasItem.mount_path, context),
+                    nasMountTargetId,
+                };
+            });
+        }
         const fcn = new fc.RosFunction(scope, fnc.key, {
-            functionName: (0, common_1.replaceReference)(fnc.name, context),
-            handler: (0, common_1.replaceReference)(fnc.handler, context),
-            runtime: (0, common_1.replaceReference)(fnc.runtime, context),
-            memorySize: (0, common_1.replaceReference)(fnc.memory, context),
-            timeout: (0, common_1.replaceReference)(fnc.timeout, context),
-            environmentVariables: (0, common_1.replaceReference)(fnc.environment, context),
-            code,
+            functionName: (0, common_1.calcRefs)(fnc.name, context),
+            memorySize: (0, common_1.calcRefs)(fnc.memory, context),
+            diskSize: (0, common_1.calcRefs)(fnc.storage?.disk, context),
+            gpuConfig: transformGpuConfig(fnc.gpu),
+            timeout: (0, common_1.calcRefs)(fnc.timeout, context),
+            environmentVariables: (0, common_1.calcRefs)(fnc.environment, context),
             logConfig,
+            vpcConfig,
+            ...runtimeConfig,
+            nasConfig: fcNas?.length
+                ? {
+                    mountPoints: fcNas?.map(({ nasMount, mountDir }) => ({
+                        mountDir,
+                        serverAddr: `${nasMount.attrMountTargetDomain}:/`,
+                    })),
+                }
+                : undefined,
         }, true);
         if (enableLog) {
-            fcn.addRosDependency(`${service}_sls`);
-            fcn.addRosDependency(`${service}_sls_logstore`);
-            fcn.addRosDependency(`${service}_sls_index`);
+            fcn.addRosDependency(slsProjectId);
+            fcn.addRosDependency(slsLogstoreId);
+            fcn.addRosDependency(slsIndexId);
         }
         if (storeInBucket) {
-            fcn.addRosDependency(`${service}_artifacts_code_deployment`);
+            fcn.addRosDependency(ossDeploymentId);
+        }
+        if (fcNas?.length) {
+            fcNas.forEach(({ nasMountTargetId }) => fcn.addRosDependency(nasMountTargetId));
         }
     });
 };

package/dist/src/stack/rosStack/index.d.ts

@@ -1,7 +1,7 @@
 import * as ros from '@alicloud/ros-cdk-core';
-import { ActionContext, ServerlessIac } from '../../types';
+import { Context, ServerlessIac } from '../../types';
 export * from './bootstrap';
 export declare class RosStack extends ros.Stack {
     private readonly service;
-    constructor(scope: ros.Construct, iac: ServerlessIac, context: ActionContext);
+    constructor(scope: ros.Construct, iac: ServerlessIac, context: Context);
 }

package/dist/src/stack/rosStack/index.js

@@ -45,17 +45,18 @@ const stage_1 = require("./stage");
 const vars_1 = require("./vars");
 const database_1 = require("./database");
 const event_1 = require("./event");
+const bucket_1 = require("./bucket");
 __exportStar(require("./bootstrap"), exports);
 class RosStack extends ros.Stack {
     constructor(scope, iac, context) {
-        super(scope, (0, common_1.replaceReference)(iac.service, context), {
+        super(scope, (0, common_1.calcRefs)(iac.service, context), {
             stackName: context.stackName,
             tags: (0, tag_1.resolveTags)(iac.tags, context),
         });
-        this.service = (0, common_1.replaceReference)(iac.service, context);
+        this.service = (0, common_1.calcRefs)(iac.service, context);
         new ros.RosInfo(this, ros.RosInfo.description, `${this.service} stack`);
         // Define Parameters
-        (0, vars_1.resloveVars)(this, iac.vars);
+        (0, vars_1.resolveVars)(this, iac.vars);
         // Define Mappings
         (0, stage_1.resolveStages)(this, iac.stages, context);
         // Define functions
@@ -64,6 +65,8 @@ class RosStack extends ros.Stack {
         (0, event_1.resolveEvents)(this, iac.events, iac.tags, context, this.service);
         // Define Databases
         (0, database_1.resolveDatabases)(this, iac.databases, context);
+        // Define Buckets
+        (0, bucket_1.resolveBuckets)(this, iac.buckets, context);
     }
 }
 exports.RosStack = RosStack;

package/dist/src/stack/rosStack/stage.js

@@ -41,6 +41,6 @@ const resolveStages = (scope, stages, context) => {
     if ((0, lodash_1.isEmpty)(stages)) {
         return undefined;
     }
-    new ros.RosMapping(scope, 'stages', { mapping: (0, common_1.replaceReference)(stages, context) });
+    new ros.RosMapping(scope, 'stages', { mapping: (0, common_1.calcRefs)(stages, context) });
 };
 exports.resolveStages = resolveStages;

package/dist/src/stack/rosStack/tag.js

@@ -4,7 +4,7 @@ exports.resolveTags = void 0;
 const common_1 = require("../../common");
 const resolveTags = (tags, context) => {
     return tags?.reduce((acc, tag) => {
-        acc[tag.key] = (0, common_1.replaceReference)(tag.value, context);
+        acc[tag.key] = (0, common_1.calcRefs)(tag.value, context);
         return acc;
     }, {});
 };

package/dist/src/stack/rosStack/vars.js

@@ -33,11 +33,11 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resloveVars = void 0;
+exports.resolveVars = void 0;
 const ros = __importStar(require("@alicloud/ros-cdk-core"));
 const ros_cdk_core_1 = require("@alicloud/ros-cdk-core");
 const lodash_1 = require("lodash");
-const resloveVars = (scope, vars) => {
+const resolveVars = (scope, vars) => {
     if ((0, lodash_1.isEmpty)(vars)) {
         return undefined;
     }
@@ -46,4 +46,4 @@ const resloveVars = (scope, vars) => {
         defaultValue: value,
     }));
 };
-exports.resloveVars = resloveVars;
+exports.resolveVars = resolveVars;

package/dist/src/types/domains/bucket.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BucketAccessEnum = void 0;
+var BucketAccessEnum;
+(function (BucketAccessEnum) {
+    BucketAccessEnum["PRIVATE"] = "PRIVATE";
+    BucketAccessEnum["PUBLIC_READ"] = "PUBLIC_READ";
+    BucketAccessEnum["PUBLIC_READ_WRITE"] = "PUBLIC_READ_WRITE";
+})(BucketAccessEnum || (exports.BucketAccessEnum = BucketAccessEnum = {}));

package/dist/src/types/domains/function.js

@@ -1,2 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.FunctionGpuEnum = exports.NasStorageClassEnum = void 0;
+var NasStorageClassEnum;
+(function (NasStorageClassEnum) {
+    NasStorageClassEnum["STANDARD_PERFORMANCE"] = "STANDARD_PERFORMANCE";
+    NasStorageClassEnum["STANDARD_CAPACITY"] = "STANDARD_CAPACITY";
+    NasStorageClassEnum["EXTREME_STANDARD"] = "EXTREME_STANDARD";
+    NasStorageClassEnum["EXTREME_ADVANCE"] = "EXTREME_ADVANCE";
+})(NasStorageClassEnum || (exports.NasStorageClassEnum = NasStorageClassEnum = {}));
+var FunctionGpuEnum;
+(function (FunctionGpuEnum) {
+    FunctionGpuEnum["TESLA_8"] = "TESLA_8";
+    FunctionGpuEnum["TESLA_12"] = "TESLA_12";
+    FunctionGpuEnum["TESLA_16"] = "TESLA_16";
+    FunctionGpuEnum["AMPERE_8"] = "AMPERE_8";
+    FunctionGpuEnum["AMPERE_12"] = "AMPERE_12";
+    FunctionGpuEnum["AMPERE_16"] = "AMPERE_16";
+    FunctionGpuEnum["AMPERE_24"] = "AMPERE_24";
+    FunctionGpuEnum["ADA_48"] = "ADA_48";
+})(FunctionGpuEnum || (exports.FunctionGpuEnum = FunctionGpuEnum = {}));

package/dist/src/types/index.d.ts

@@ -4,12 +4,14 @@ import { EventDomain, EventRaw } from './domains/event';
 import { DatabaseDomain, DatabaseRaw } from './domains/database';
 import { FunctionDomain, FunctionRaw } from './domains/function';
 import { Provider } from './domains/provider';
+import { BucketDomain, BucketRaw } from './domains/bucket';
 export * from './domains/database';
 export * from './domains/event';
 export * from './domains/function';
 export * from './domains/tag';
 export * from './domains/vars';
 export * from './domains/context';
+export * from './domains/bucket';
 export * from './assets';
 export type ServerlessIacRaw = {
     version: string;
@@ -27,6 +29,9 @@ export type ServerlessIacRaw = {
     databases: {
         [key: string]: DatabaseRaw;
     };
+    buckets: {
+        [key: string]: BucketRaw;
+    };
 };
 export type ServerlessIac = {
     version: string;
@@ -41,4 +46,5 @@ export type ServerlessIac = {
     functions?: Array<FunctionDomain>;
     events?: Array<EventDomain>;
     databases?: Array<DatabaseDomain>;
+    buckets?: Array<BucketDomain>;
 };

package/dist/src/types/index.js

@@ -20,4 +20,5 @@ __exportStar(require("./domains/function"), exports);
 __exportStar(require("./domains/tag"), exports);
 __exportStar(require("./domains/vars"), exports);
 __exportStar(require("./domains/context"), exports);
+__exportStar(require("./domains/bucket"), exports);
 __exportStar(require("./assets"), exports);

package/dist/src/validator/bucketSchema.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bucketSchema = void 0;
+exports.bucketSchema = {
+    $id: 'https://serverlessinsight.geekfun.club/schemas/bucketschema.json',
+    type: 'object',
+    patternProperties: {
+        '.*': {
+            type: 'object',
+            properties: {
+                name: {
+                    type: 'string',
+                },
+                storage: {
+                    type: 'object',
+                    properties: {
+                        class: {
+                            type: 'string',
+                        },
+                    },
+                    required: ['class'],
+                },
+                versioning: {
+                    type: 'object',
+                    properties: {
+                        status: {
+                            type: 'string',
+                        },
+                    },
+                    required: ['status'],
+                },
+                security: {
+                    type: 'object',
+                    properties: {
+                        access: {
+                            type: 'string',
+                            enum: ['PRIVATE', 'PUBLIC_READ', 'PUBLIC_READ_WRITE'],
+                        },
+                        force_delete: {
+                            type: 'boolean',
+                        },
+                        sse_algorithm: {
+                            type: 'string',
+                        },
+                        sse_kms_master_key_id: {
+                            type: 'string',
+                        },
+                    },
+                },
+                website: {
+                    type: 'object',
+                    properties: {
+                        code: {
+                            type: 'string',
+                        },
+                        domain: {
+                            type: 'string',
+                        },
+                        index: {
+                            type: 'string',
+                        },
+                        error_page: {
+                            type: 'string',
+                        },
+                        error_code: {
+                            type: 'number',
+                        },
+                    },
+                    required: ['code'],
+                },
+            },
+            required: ['name'],
+            additionalProperties: false,
+        },
+    },
+};