@geek-fun/serverlessinsight 0.2.0 → 0.3.0

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

@@ -0,0 +1,126 @@
+"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.resolveBuckets = void 0;
+const types_1 = require("../../types");
+const oss = __importStar(require("@alicloud/ros-cdk-oss"));
+const ros = __importStar(require("@alicloud/ros-cdk-core"));
+const common_1 = require("../../common");
+const ossDeployment = __importStar(require("@alicloud/ros-cdk-ossdeployment"));
+const dns = __importStar(require("@alicloud/ros-cdk-dns"));
+const node_path_1 = __importDefault(require("node:path"));
+const ros_cdk_ram_1 = require("@alicloud/ros-cdk-ram");
+const aclMap = new Map([
+    [types_1.BucketAccessEnum.PRIVATE, 'private'],
+    [types_1.BucketAccessEnum.PUBLIC_READ, 'public-read'],
+    [types_1.BucketAccessEnum.PUBLIC_READ_WRITE, 'public-read-write'],
+]);
+const resolveBuckets = (scope, buckets, context) => {
+    if (!buckets) {
+        return undefined;
+    }
+    const bucketSources = buckets.some((bucket) => bucket?.website?.code);
+    let siAutoOssDeploymentBucketRole;
+    if (bucketSources) {
+        siAutoOssDeploymentBucketRole = new ros_cdk_ram_1.RosRole(scope, 'si_auto_od_bucket_role', {
+            roleName: ros.Fn.sub('si-auto-od-bucket-role-${ALIYUN::StackId}'),
+            description: 'roles created by ServerlessInsight for oss deployment to put files to oss bucket during deployment',
+            deletionForce: false,
+            ignoreExisting: false,
+            assumeRolePolicyDocument: {
+                version: '1',
+                statement: [
+                    {
+                        action: 'sts:AssumeRole',
+                        effect: 'Allow',
+                        principal: { service: ['fc.aliyuncs.com'] },
+                    },
+                ],
+            },
+            policyAttachments: {
+                system: ['AliyunOSSFullAccess', 'AliyunLogFullAccess'],
+            },
+        }, true);
+    }
+    buckets.forEach((bucket) => {
+        const ossBucket = new oss.Bucket(scope, (0, common_1.replaceReference)(bucket.key, context), {
+            bucketName: (0, common_1.replaceReference)(bucket.name, context),
+            accessControl: aclMap.get((0, common_1.replaceReference)(bucket.security?.acl, context) ?? ''),
+            websiteConfigurationV2: bucket.website
+                ? {
+                    indexDocument: {
+                        type: '0',
+                        suffix: (0, common_1.replaceReference)(bucket.website.index, context),
+                        supportSubDir: 'true',
+                    },
+                    errorDocument: {
+                        httpStatus: `${(0, common_1.replaceReference)(bucket.website.error_code, context)}`,
+                        key: (0, common_1.replaceReference)(bucket.website.error_page, context),
+                    },
+                }
+                : undefined,
+        });
+        if (bucket.website?.code) {
+            const filePath = node_path_1.default.resolve(process.cwd(), (0, common_1.replaceReference)(bucket.website.code, context));
+            new ossDeployment.BucketDeployment(scope, `si_auto_${bucket.key}_bucket_code_deployment`, {
+                sources: (0, common_1.getAssets)(filePath),
+                destinationBucket: ossBucket.attrName,
+                roleArn: siAutoOssDeploymentBucketRole.attrArn,
+                timeout: 3000,
+                logMonitoring: false,
+                retainOnCreate: false,
+            }, true);
+        }
+        if (bucket.website?.domain) {
+            const { rr, domainName } = (0, common_1.splitDomain)(bucket.website.domain);
+            new oss.Domain(scope, `${bucket.key}_custom_domain_${(0, common_1.encodeBase64ForRosId)(bucket.website.domain)}`, {
+                bucketName: ossBucket.attrName,
+                domainName: (0, common_1.replaceReference)(bucket.website.domain, context),
+            });
+            new dns.DomainRecord(scope, `${bucket.key}_custom_domain_record_${(0, common_1.encodeBase64ForRosId)(bucket.website.domain)}`, {
+                domainName: domainName,
+                rr,
+                type: 'CNAME',
+                value: [types_1.BucketAccessEnum.PUBLIC_READ, types_1.BucketAccessEnum.PUBLIC_READ_WRITE].includes(bucket.security?.acl ?? '')
+                    ? ossBucket.attrDomainName
+                    : ossBucket.attrInternalDomainName,
+            });
+        }
+    });
+};
+exports.resolveBuckets = resolveBuckets;

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

@@ -39,14 +39,17 @@ 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),
+    if (!apiGateway?.length)
+        return;
+    apiGateway.forEach((event) => {
+        const gatewayAccessRole = new ram.RosRole(scope, (0, common_1.replaceReference)(`${event.key}_role`, context), {
+            roleName: (0, common_1.replaceReference)(`${service}-${event.name}-agw-access-role`, context),
             description: (0, common_1.replaceReference)(`${service} role`, context),
             assumeRolePolicyDocument: {
                 version: '1',
@@ -62,7 +65,7 @@ const resolveEvents = (scope, events, tags, context, service) => {
             },
             policies: [
                 {
-                    policyName: (0, common_1.replaceReference)(`${service}-policy`, context),
+                    policyName: (0, common_1.replaceReference)(`${service}-${event.name}-policy`, context),
                     policyDocument: {
                         version: '1',
                         statement: [
@@ -82,55 +85,59 @@ const resolveEvents = (scope, events, tags, context, service) => {
             tags: (0, common_1.replaceReference)(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 dnsRecordRosId = `${event.key}_custom_domain_record_${(0, common_1.encodeBase64ForRosId)(event.domain.domain_name)}`;
+            const { domainName, rr } = (0, common_1.splitDomain)(event.domain?.domain_name);
+            new dns.DomainRecord(scope, dnsRecordRosId, {
+                domainName,
+                rr,
+                type: 'CNAME',
+                value: apiGatewayGroup.attrSubDomain,
+            });
+            const agwCustomDomain = new agw.RosCustomDomain(scope, `${event.key}_custom_domain_${(0, common_1.encodeBase64ForRosId)(event.domain.domain_name)}`, {
+                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(dnsRecordRosId);
+        }
+        event.triggers.forEach((trigger) => {
+            const key = (0, common_1.encodeBase64ForRosId)((0, common_1.replaceReference)(`${trigger.method}_${trigger.path}`, context));
+            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),
                     },
-                    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.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`,
             });
         });
-    }
+    });
 };
 exports.resolveEvents = resolveEvents;

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

@@ -34,16 +34,67 @@ 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 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`,
@@ -55,11 +106,18 @@ const resolveFunctions = (scope, functions, tags, context, service) => {
         logstoreName: slsLogstore.attrLogstoreName,
         fullTextIndex: { enable: true },
     }, true);
+    if (enableLog) {
+        logConfig = {
+            project: slsLogstore.attrProjectName,
+            logstore: slsLogstore.attrLogstoreName,
+            enableRequestMetrics: true,
+        };
+    }
     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) };
+        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`;
@@ -73,36 +131,109 @@ const resolveFunctions = (scope, functions, tags, context, service) => {
         }, 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)(fnc.code.path) > common_1.CODE_ZIP_SIZE_LIMIT;
+        if (fnc.container) {
+            runtimeConfig = {
+                runtime: 'custom-container',
+                handler: 'index.handler',
+                customContainerConfig: {
+                    image: fnc.container.image,
+                    command: fnc.container.cmd?.split(' '),
+                    port: fnc.container.port,
+                },
+            };
+        }
+        else {
+            let code = {
+                zipFile: (0, common_1.resolveCode)(fnc.code.path),
+            };
+            if (storeInBucket) {
+                code = {
+                    ossBucketName: destinationBucketName,
+                    ossObjectName: fileSources?.find(({ fcName }) => fcName === (0, common_1.replaceReference)(fnc.name, context))?.objectKey,
+                };
+            }
+            runtimeConfig = {
+                code,
+                handler: (0, common_1.replaceReference)(fnc.code.handler, context),
+                runtime: (0, common_1.replaceReference)(fnc.code.runtime, context),
             };
         }
+        let vpcConfig = undefined;
+        if (fnc.network) {
+            const securityGroup = new ecs.SecurityGroup(scope, `${fnc.key}_security_group`, {
+                securityGroupName: fnc.network.security_group.name,
+                vpcId: (0, common_1.replaceReference)(fnc.network.vpc_id, context),
+                tags: (0, common_1.replaceReference)(tags, context),
+                securityGroupIngress: transformSecurityRules(fnc.network.security_group.ingress, 'INGRESS'),
+                securityGroupEgress: transformSecurityRules(fnc.network.security_group.egress, 'EGRESS'),
+            }, true);
+            vpcConfig = {
+                vpcId: (0, common_1.replaceReference)(fnc.network.vpc_id, context),
+                vSwitchIds: (0, common_1.replaceReference)(fnc.network.subnet_ids, context),
+                securityGroupId: securityGroup.attrSecurityGroupId,
+            };
+        }
+        let fcNas;
+        if (fnc.storage?.nas) {
+            fcNas = fnc.storage.nas.map((nasItem) => {
+                const { fileSystemType, storageType } = storageClassMap[nasItem.storage_class];
+                const accessGroup = new nas.AccessGroup(scope, `${fnc.key}_nas_access_${(0, common_1.encodeBase64ForRosId)(nasItem.mount_path)}`, {
+                    accessGroupName: `${fnc.name}-nas-access-${(0, common_1.encodeBase64ForRosId)(nasItem.mount_path)}`,
+                    accessGroupType: 'Vpc',
+                }, true);
+                const nasResource = new nas.FileSystem(scope, `${fnc.key}_nas_${(0, common_1.encodeBase64ForRosId)(nasItem.mount_path)}`, {
+                    fileSystemType,
+                    storageType,
+                    protocolType: 'NFS',
+                    tags: [
+                        ...((0, common_1.replaceReference)(tags, context) ?? []),
+                        { key: 'function-name', value: fnc.name },
+                    ],
+                }, true);
+                const nasMountTarget = new nas.MountTarget(scope, `${fnc.key}_nas_mount_${(0, common_1.encodeBase64ForRosId)(nasItem.mount_path)}`, {
+                    fileSystemId: nasResource.attrFileSystemId,
+                    networkType: 'Vpc',
+                    accessGroupName: accessGroup.attrAccessGroupName,
+                    vpcId: fnc.network.vpc_id,
+                    vSwitchId: fnc.network.subnet_ids[0],
+                }, true);
+                return { nas: nasResource, nasMount: nasMountTarget, mountDir: nasItem.mount_path };
+            });
+        }
         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),
+            diskSize: fnc.storage?.disk,
+            gpuConfig: transformGpuConfig(fnc.gpu),
             timeout: (0, common_1.replaceReference)(fnc.timeout, context),
             environmentVariables: (0, common_1.replaceReference)(fnc.environment, context),
-            code,
-            logConfig: {
-                project: slsLogstore.attrProjectName,
-                logstore: slsLogstore.attrLogstoreName,
-                enableRequestMetrics: true,
-            },
+            logConfig,
+            vpcConfig,
+            ...runtimeConfig,
+            nasConfig: fcNas?.length
+                ? {
+                    mountPoints: fcNas?.map(({ nasMount, mountDir }) => ({
+                        mountDir,
+                        serverAddr: `${nasMount.attrMountTargetDomain}:/`,
+                    })),
+                }
+                : undefined,
         }, true);
-        fcn.addRosDependency(`${service}_sls`);
-        fcn.addRosDependency(`${service}_sls_logstore`);
-        fcn.addRosDependency(`${service}_sls_index`);
+        if (enableLog) {
+            fcn.addRosDependency(`${service}_sls`);
+            fcn.addRosDependency(`${service}_sls_logstore`);
+            fcn.addRosDependency(`${service}_sls_index`);
+        }
         if (storeInBucket) {
             fcn.addRosDependency(`${service}_artifacts_code_deployment`);
         }
+        if (fcNas?.length) {
+            fcNas.forEach((nasItem) => {
+                fcn.addRosDependency(`${fnc.key}_nas_mount_${(0, common_1.encodeBase64ForRosId)(nasItem.mountDir)}`);
+            });
+        }
     });
 };
 exports.resolveFunctions = resolveFunctions;

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

@@ -45,6 +45,7 @@ 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) {
@@ -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/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,
+        },
+    },
+};