feat(github-codestarconnection): add github code star connection construct (#12)

We create a code star connection for github with default values

Author: antonio-marquez-perez

.cz-config.js

@@ -26,6 +26,7 @@ module.exports = {
 
   scopes: [
     { name: 'codestarconnection' },
+    { name: 'github-codestarconnection' },
     { name: 'projen' },
     { name: 'docs' },
   ],

.projenrc.ts

@@ -13,6 +13,7 @@ const project = new awscdk.AwsCdkConstructLibrary({
   constructsVersion: '10.3.0',
   repositoryUrl: 'https://github.com/JumpToTheCloud/aws-codestarconnection',
   prettier: true,
+  keywords: ['aws', 'cdk', 'codestarconnection'],
   prettierOptions: {
     settings: {
       trailingComma: TrailingComma.ES5,

API.md

@@ -18,6 +18,7 @@ npm install @jttc/aws-codestarconnection
 
 The Construct Library has the following L2 Construct:
 
-| Construct               | Description                                                    |
-|-------------------------|----------------------------------------------------------------|
-| [CodeStarConnection](#) | We create a Code Star Connection for every Provider available  |
+| Construct                     | Description                                                    |
+|-------------------------------|----------------------------------------------------------------|
+| [CodeStarConnection](#)       | We create a Code Star Connection for every Provider available  |
+| [GithubCodeStarConnection](#) | We create a Code Star Connection for Github                    |

docs/index.md

@@ -299,6 +299,21 @@ export abstract class CodeStarConnectionBase
    */
   public abstract readonly connectionArn: string;
 
+  /**
+   * Validate if the name of the code connection is
+   * longer thatn 32 characters
+   * @param {string} name Name of the connection
+   * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codestarconnections-connection.html#cfn-codestarconnections-connection-connectionname
+   */
+  public validateConnectionName(name: string): void {
+    // Rules codified from https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codestarconnections-connection.html#cfn-codestarconnections-connection-connectionname
+    if (name.length < 2 || name.length > 32) {
+      Annotations.of(this).addError(
+        'Connection Name must be at least 1 and no more than 32 characters'
+      );
+    }
+  }
+
   /**
    * Grant the given principal identity permissions to perform the actions on this code star connection
    */
@@ -470,13 +485,4 @@ export class CodeStarConnection extends CodeStarConnectionBase {
     this.connectionName = props.connectionName;
     this.connectionArn = resource.attrConnectionArn;
   }
-
-  private validateConnectionName(qualifier: string): void {
-    // Rules codified from https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codestarconnections-connection.html#cfn-codestarconnections-connection-connectionname
-    if (qualifier.length < 2 || qualifier.length > 32) {
-      Annotations.of(this).addError(
-        'Connection Name must be at least 1 and no more than 32 characters'
-      );
-    }
-  }
 }

package.json

@@ -0,0 +1,102 @@
+import { RemovalPolicy, Tag } from 'aws-cdk-lib';
+import { CfnConnection } from 'aws-cdk-lib/aws-codestarconnections';
+import { Construct } from 'constructs';
+
+import {
+  CodeStarConnectionBase,
+  CodeStarConnectionProviderType,
+  ICodeStarConnection,
+} from './code-star-connection';
+
+export interface GithubCodeStarConnetionProps {
+  /**
+   * The name of the connection.
+   * Connection names must be in an AWS user account.
+   */
+  readonly connectionName?: string;
+
+  /**
+   * The Amazon Resource Name (ARN) of the host associated with the connection.
+   */
+  readonly hostArn?: string;
+
+  /**
+   * The list of tags associated with the connection.
+   */
+  readonly tags?: Tag[];
+
+  /**
+   * Determine what happens to the code star connection when the resource/stack is deleted.
+   *
+   * @default RemovalPolicy.Retain
+   */
+  readonly removalPolicy?: RemovalPolicy;
+}
+
+/**
+ * Define a Github CodeStar Connection resource
+ * @resource AWS::CodeStarConnections::Connection
+ * @example
+ *   new GithubCodeStarConnection(this, 'GithubConnection')
+ */
+export class GithubCodeStarConnection extends CodeStarConnectionBase {
+  /**
+   * Import an externally defined Code Star Connection using its ARN.
+   *
+   * @param scope  the construct that will "own" the imported key.
+   * @param id     the id of the imported code star conection in the construct tree.
+   * @param codestarConnectionArn the ARN of an existing Code Star Connection.
+   */
+  public static fromCodeStarConnectionArn(
+    scope: Construct,
+    id: string,
+    codestarConnectionArn: string
+  ): ICodeStarConnection {
+    class Import extends CodeStarConnectionBase {
+      public connectionName = '';
+      public connectionArn = codestarConnectionArn;
+    }
+
+    return new Import(scope, id, {
+      environmentFromArn: codestarConnectionArn,
+    });
+  }
+
+  /**
+   * The name of the CodeStar connection
+   */
+  public readonly connectionName: string;
+
+  /**
+   * The ARN of the Code Star connection
+   */
+  public readonly connectionArn: string;
+
+  constructor(
+    scope: Construct,
+    id: string,
+    props?: GithubCodeStarConnetionProps
+  ) {
+    super(scope, id, {
+      // physicalName: props.connectionName,
+    });
+
+    this.connectionName = 'github-connection';
+
+    if (props && props.connectionName) {
+      this.validateConnectionName(props.connectionName);
+      this.connectionName = props.connectionName;
+    }
+
+    const resource = new CfnConnection(this, 'Resource', {
+      connectionName: this.connectionName,
+      providerType: CodeStarConnectionProviderType.GITHUB,
+      hostArn: props?.hostArn,
+      tags: props?.tags,
+    });
+
+    resource.applyRemovalPolicy(props?.removalPolicy);
+
+    this.connectionArn = resource.attrConnectionArn;
+  }
+}

src/code-star-connection.ts

@@ -1 +1,2 @@
 export * from './code-star-connection';
+export * from './github-code-star-connection';

src/github-code-star-connection.ts

@@ -1,9 +1,14 @@
 import { Stack } from 'aws-cdk-lib';
 import { Template } from 'aws-cdk-lib/assertions';
 
-import { CodeStarConnection, CodeStarConnectionProviderType } from '../src';
+import {
+  CodeStarConnection,
+  CodeStarConnectionProviderType,
+} from '../src/code-star-connection';
 
-describe('Snapshot test validation', () => {
+import { GithubCodeStarConnection } from '../src/github-code-star-connection';
+
+describe('Code Star Connection Snapshot test validation', () => {
   // Given a new Stack
   const stack = new Stack();
 
@@ -19,3 +24,17 @@ describe('Snapshot test validation', () => {
     expect(template.toJSON()).toMatchSnapshot();
   });
 });
+
+describe('Github Code Star Snapshot test validation', () => {
+  // Given a new Stack
+  const stack = new Stack();
+
+  // WHEN
+  new GithubCodeStarConnection(stack, 'MyGithubConnection');
+
+  // THEN
+  it('Code Star Connection validation test', () => {
+    const template = Template.fromStack(stack);
+    expect(template.toJSON()).toMatchSnapshot();
+  });
+});

src/index.ts

@@ -0,0 +1,103 @@
+import { App, Stack } from 'aws-cdk-lib';
+import { Template } from 'aws-cdk-lib/assertions';
+
+import { AnyPrincipal, Role } from 'aws-cdk-lib/aws-iam';
+import {
+  CodeStarConnectionPolicyActions,
+  GithubCodeStarConnection,
+} from '../src';
+
+describe('Code Star Connection', () => {
+  // GIVEN
+  let stack = new Stack();
+
+  // WHEN
+  new GithubCodeStarConnection(stack, 'GithubCodeStarConnection');
+
+  it('should create a Code Star Connection', () => {
+    // THEN
+    Template.fromStack(stack).resourceCountIs(
+      'AWS::CodeStarConnections::Connection',
+      1
+    );
+  });
+
+  it('should have a default connection name', () => {
+    // THEN
+    Template.fromStack(stack).hasResourceProperties(
+      'AWS::CodeStarConnections::Connection',
+      {
+        ConnectionName: 'github-connection',
+      }
+    );
+  });
+
+  it('should have a Github provider', () => {
+    // THEN
+    Template.fromStack(stack).hasResourceProperties(
+      'AWS::CodeStarConnections::Connection',
+      {
+        ProviderType: 'GitHub',
+      }
+    );
+  });
+
+  it('should have Retention Policy by default', () => {
+    Template.fromStack(stack).hasResource(
+      'AWS::CodeStarConnections::Connection',
+      {
+        DeletionPolicy: 'Retain',
+        UpdateReplacePolicy: 'Retain',
+      }
+    );
+  });
+
+  it('should thrown an error if the connection name is to long', () => {
+    // GIVEN
+    const app = new App();
+    stack = new Stack(app, 'TestStack');
+
+    // WHEN
+    new GithubCodeStarConnection(stack, 'CodeStarConnection', {
+      connectionName: 'test-connection-is-longer-than-32-characters',
+    });
+
+    expect(() =>
+      Template.fromStack(app.synth().getStackArtifact(stack.stackId).template)
+    ).toThrowError();
+  });
+});
+
+describe('Github Code Star Connection Static methods', () => {
+  it('should return a instance of the github code star connection and use the grantUse method', () => {
+    // GIVEN
+    const app = new App();
+    const stack = new Stack(app, 'TestStack');
+
+    // WHEN
+    const codestarConnection =
+      GithubCodeStarConnection.fromCodeStarConnectionArn(
+        stack,
+        'CodeStarConnectionFromArn',
+        'arn:aws:codestar-connections:eu-west-1:123456789012:connection/8c86942e-a7ca-4a4a-8b63-e2f7f5efaeee'
+      );
+
+    const role = new Role(stack, 'Role', {
+      assumedBy: new AnyPrincipal(),
+    });
+
+    codestarConnection.grantUse(role);
+
+    Template.fromStack(stack).hasResourceProperties('AWS::IAM::Policy', {
+      PolicyDocument: {
+        Statement: [
+          {
+            Action: CodeStarConnectionPolicyActions.USE_CONNECTION,
+            Effect: 'Allow',
+            Resource: codestarConnection.connectionArn,
+          },
+        ],
+      },
+    });
+  });
+});