feat: oss resource definition

Signed-off-by: seven <[email protected]>

Author: Blankll

src/parser/bucketParser.ts

@@ -0,0 +1,30 @@
+import { BucketDomain, BucketRaw } from '../types';
+
+export const parseBucket = (buckets: {
+  [key: string]: BucketRaw;
+}): Array<BucketDomain> | undefined => {
+  if (!buckets) {
+    return undefined;
+  }
+  return Object.entries(buckets).map(([key, bucket]) => ({
+    key,
+    name: bucket.name,
+    storage: bucket.storage,
+    versioning: bucket.versioning,
+    security: bucket.security
+      ? {
+          force_delete: bucket.security.force_delete ?? false,
+          sse_algorithm: bucket.security.sse_algorithm,
+          sse_kms_master_key_id: bucket.security.sse_kms_master_key_id,
+        }
+      : undefined,
+
+    website: bucket.website
+      ? {
+          index: bucket.website.index ?? 'index.html',
+          error_page: bucket.website.error_page ?? '404.html',
+          error_code: bucket.website.error_code ?? 404,
+        }
+      : undefined,
+  }));
+};

src/stack/rosStack/bucket.ts

@@ -1,19 +1,32 @@
-import { ActionContext, DatabaseDomain } from '../../types';
+import { ActionContext, BucketDomain } from '../../types';
 import * as oss from '@alicloud/ros-cdk-oss';
 import * as ros from '@alicloud/ros-cdk-core';
 import { replaceReference } from '../../common';
 
 export const resolveBuckets = (
   scope: ros.Construct,
-  buckets: Array<DatabaseDomain> | undefined,
+  buckets: Array<BucketDomain> | undefined,
   context: ActionContext,
 ) => {
   if (!buckets) {
     return undefined;
   }
   buckets.forEach((bucket) => {
     new oss.Bucket(scope, replaceReference(bucket.key, context), {
-      bucketName: bucket.name,
+      bucketName: replaceReference(bucket.name, context),
+      websiteConfigurationV2: bucket.website
+        ? {
+            indexDocument: {
+              type: '0',
+              suffix: replaceReference(bucket.website.index, context),
+              supportSubDir: 'true',
+            },
+            errorDocument: {
+              httpStatus: `${replaceReference(bucket.website.error_code, context)}`,
+              key: replaceReference(bucket.website.error_page, context),
+            },
+          }
+        : undefined,
     });
   });
 };

src/stack/rosStack/index.ts

@@ -7,6 +7,7 @@ import { resolveStages } from './stage';
 import { resloveVars } from './vars';
 import { resolveDatabases } from './database';
 import { resolveEvents } from './event';
+import { resolveBuckets } from './bucket';
 
 export * from './bootstrap';
 
@@ -32,5 +33,7 @@ export class RosStack extends ros.Stack {
     resolveEvents(this, iac.events, iac.tags, context, this.service);
     // Define Databases
     resolveDatabases(this, iac.databases, context);
+    // Define Buckets
+    resolveBuckets(this, iac.buckets, context);
   }
 }

src/types/domains/bucket.ts

@@ -1,28 +1,42 @@
-export type BucketDomain = {
+export type BucketRaw = {
   name: string;
-  storage: {
+  storage?: {
     class: string;
   };
-  versioning: {
+  versioning?: {
     status: string;
   };
-  lifecycle: {
-    rule: {
-      id: string;
-    };
+
+  security?: {
+    force_delete?: boolean;
+    sse_algorithm?: string;
+    sse_kms_master_key_id?: string;
+  };
+  website?: {
+    index?: string;
+    error_page?: string;
+    error_code?: number;
+  };
+};
+
+export type BucketDomain = {
+  key: string;
+  name: string;
+  storage?: {
+    class: string;
+  };
+  versioning?: {
     status: string;
-    expiration: {
-      days: number;
-    };
   };
 
-  security: {
+  security?: {
     force_delete: boolean;
-    sse_algorithm: string;
-    sse_kms_master_key_id: string;
+    sse_algorithm?: string;
+    sse_kms_master_key_id?: string;
   };
-  website: {
+  website?: {
     index: string;
-    error: string;
+    error_page: string;
+    error_code: number;
   };
 };

src/types/index.ts

@@ -4,6 +4,7 @@ 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';
@@ -24,6 +25,7 @@ export type ServerlessIacRaw = {
   functions: { [key: string]: FunctionRaw };
   events: { [key: string]: EventRaw };
   databases: { [key: string]: DatabaseRaw };
+  buckets: { [key: string]: BucketRaw };
 };
 
 export type ServerlessIac = {
@@ -36,4 +38,5 @@ export type ServerlessIac = {
   functions?: Array<FunctionDomain>;
   events?: Array<EventDomain>;
   databases?: Array<DatabaseDomain>;
+  buckets?: Array<BucketDomain>;
 };

tests/fixtures/deployFixture.ts

@@ -1242,3 +1242,86 @@ export const esServerlessMinimumRos = {
     },
   },
 };
+
+export const bucketMinimumIac = {
+  version: '0.0.1',
+  provider: {
+    name: 'aliyun',
+    region: 'cn-hangzhou',
+  },
+  service: 'my-bucket-service',
+  buckets: [
+    {
+      key: 'my_bucket',
+      name: 'my-bucket',
+    },
+  ],
+} as unknown as ServerlessIac;
+
+export const bucketMinimumRos = {
+  Description: 'my-bucket-service stack',
+  Metadata: { 'ALIYUN::ROS::Interface': { TemplateTags: ['Create by ROS CDK'] } },
+  ROSTemplateFormatVersion: '2015-09-01',
+  Resources: {
+    my_bucket: {
+      Properties: {
+        BucketName: 'my-bucket',
+        AccessControl: 'private',
+        DeletionForce: false,
+        EnableOssHdfsService: false,
+        RedundancyType: 'LRS',
+      },
+      Type: 'ALIYUN::OSS::Bucket',
+    },
+  },
+};
+
+export const bucketWithWebsiteIac = {
+  version: '0.0.1',
+  provider: {
+    name: 'aliyun',
+    region: 'cn-hangzhou',
+  },
+  service: 'my-bucket-service',
+  buckets: [
+    {
+      key: 'my_bucket',
+      name: 'my-bucket',
+      website: {
+        index: 'index.html',
+        error_page: '404.html',
+        error_code: 404,
+      },
+    },
+  ],
+} as ServerlessIac;
+
+export const bucketWithWebsiteRos = {
+  Description: 'my-bucket-service stack',
+  Metadata: { 'ALIYUN::ROS::Interface': { TemplateTags: ['Create by ROS CDK'] } },
+  ROSTemplateFormatVersion: '2015-09-01',
+  Resources: {
+    my_bucket: {
+      Properties: {
+        BucketName: 'my-bucket',
+        AccessControl: 'private',
+        DeletionForce: false,
+        EnableOssHdfsService: false,
+        RedundancyType: 'LRS',
+
+        WebsiteConfigurationV2: {
+          ErrorDocument: {
+            HttpStatus: '404',
+            Key: '404.html',
+          },
+          IndexDocument: {
+            Suffix: 'index.html',
+            SupportSubDir: 'true',
+            Type: '0',
+          },
+        },
+      },
+      Type: 'ALIYUN::OSS::Bucket',
+    },
+  },
+};

tests/stack/deploy.test.ts

@@ -1,6 +1,10 @@
 import { deployStack } from '../../src/stack';
 import { ActionContext } from '../../src/types';
 import {
+  bucketMinimumIac,
+  bucketMinimumRos,
+  bucketWithWebsiteIac,
+  bucketWithWebsiteRos,
   esServerlessMinimumIac,
   esServerlessMinimumRos,
   largeCodeRos,
@@ -177,4 +181,34 @@ describe('Unit tests for stack deployment', () => {
       ]);
     });
   });
+
+  describe('unit test for deploy of buckets', () => {
+    it('should deploy bucket when minimum fields provided', async () => {
+      const stackName = 'my-demo-bucket-stack';
+      mockedRosStackDeploy.mockResolvedValue(stackName);
+
+      await deployStack(stackName, bucketMinimumIac, { stackName } as ActionContext);
+
+      expect(mockedRosStackDeploy).toHaveBeenCalledTimes(2);
+      expect(mockedRosStackDeploy.mock.calls[1]).toEqual([
+        stackName,
+        bucketMinimumRos,
+        { stackName },
+      ]);
+    });
+
+    it('should deploy bucket as a website when website  field is provided', async () => {
+      const stackName = 'my-website-bucket-stack';
+      mockedRosStackDeploy.mockResolvedValue(stackName);
+
+      await deployStack(stackName, bucketWithWebsiteIac, { stackName } as ActionContext);
+
+      expect(mockedRosStackDeploy).toHaveBeenCalledTimes(2);
+      expect(mockedRosStackDeploy.mock.calls[1]).toEqual([
+        stackName,
+        bucketWithWebsiteRos,
+        { stackName },
+      ]);
+    });
+  });
 });