@takumi-stack/core 1.0.0 → 1.0.1

package/prefab/integration/queue/index.ts

@@ -0,0 +1,94 @@
+import { Duration } from 'aws-cdk-lib';
+import { Rule } from 'aws-cdk-lib/aws-events';
+import { SqsQueue } from 'aws-cdk-lib/aws-events-targets';
+import { Queue, QueueProps } from 'aws-cdk-lib/aws-sqs';
+import { Construct } from 'constructs';
+
+import { EventConfig } from '@takumi-stack/sdk';
+
+import { ServiceStack, getLogicalName, getResourceName, Modifier, getShortResourceName } from '../../../common';
+
+import { EventBusPrefab } from '../event-bus';
+
+export type FifoProperties = Pick<QueueProps, 'contentBasedDeduplication' | 'deduplicationScope' | 'fifoThroughputLimit'>;
+
+export type QueuePrefabParams = {
+  name: string;
+  maxRetries?: number;
+  dlqRetention?: Duration;
+  visibilityTimeout?: Duration;
+  deliveryDelay?: Duration;
+  dlq?: Queue;
+  fifo?: FifoProperties;
+  eventBus?: EventBusPrefab;
+  eventConfig?: EventConfig[];
+};
+
+export class QueuePrefab extends Construct {
+  public readonly dlq: Queue;
+  public readonly queue: Queue;
+
+  constructor(service: ServiceStack, params: QueuePrefabParams) {
+    super(service, getLogicalName(QueuePrefab.name, params.name));
+
+    const queueName = getResourceName(params.name, service.props);
+
+    this.dlq =
+      params.dlq ||
+      new Queue(this, getLogicalName(params.name, 'DLQ'), {
+        queueName: params.fifo ? `${queueName}-dlq.fifo` : `${queueName}-dlq`,
+        retentionPeriod: params.dlqRetention || Duration.hours(48),
+        ...(params.fifo ? { fifo: true } : {}),
+      });
+
+    this.queue = new Queue(this, getLogicalName(params.name, 'Queue'), {
+      queueName: params.fifo ? `${queueName}.fifo` : queueName,
+      visibilityTimeout: params.visibilityTimeout || Duration.seconds(30),
+      deliveryDelay: params.deliveryDelay || Duration.seconds(0),
+      ...(params.fifo ? { fifo: true, ...params.fifo } : {}),
+      deadLetterQueue: {
+        queue: this.dlq,
+        maxReceiveCount: params.maxRetries || 3,
+      },
+    });
+
+    if (params.eventBus && params.eventConfig) {
+      const source = params.eventConfig.map((e) => e.source);
+      const detailType = params.eventConfig.map((e) => e.name);
+      const detailRules = params.eventConfig.reduce((memo, e) => ({ ...memo, ...(e.detail || {}) }), {});
+
+      new Rule(service, getLogicalName('EventProcessorRule', params.name), {
+        ruleName: getShortResourceName(params.name, service.props),
+        eventBus: params.eventBus?.bus,
+        eventPattern: {
+          ...(source.filter((e) => !!e).length > 0 ? { source } : {}),
+          ...(detailType.filter((e) => !!e).length > 0 ? { detailType } : {}),
+          ...(Object.keys(detailRules).length > 0 ? { detail: detailRules } : {}),
+        },
+        targets: [new SqsQueue(this.queue)],
+      });
+    }
+  }
+
+  // Mods
+  public useMod(variableName = 'DEST_QUEUE', mods: ((queue: Queue) => any)[]): Modifier {
+    return (lambda) => {
+      lambda.addEnvironment(variableName, this.queue.queueUrl);
+      mods.map((fn) => fn(this.queue)(lambda));
+    };
+  }
+
+  // Class Mods
+  public static modifier = {
+    writer: (queue: Queue): Modifier => {
+      return (lambda) => {
+        queue.grantSendMessages(lambda);
+      };
+    },
+  };
+
+  // Instance Mods
+  public useModWriter(variableName = 'DEST_QUEUE'): Modifier {
+    return this.useMod(variableName, [QueuePrefab.modifier.writer]);
+  }
+}

package/prefab/integration/topic/index.ts

@@ -0,0 +1,57 @@
+import { NodejsFunction } from 'aws-cdk-lib/aws-lambda-nodejs';
+import { Topic } from 'aws-cdk-lib/aws-sns';
+import { SqsSubscription } from 'aws-cdk-lib/aws-sns-subscriptions';
+import { Queue } from 'aws-cdk-lib/aws-sqs';
+import { Construct } from 'constructs';
+
+import { ServiceStack, getLogicalName, getResourceName, Modifier } from '../../../common';
+
+export type CustomTopicParams = {
+  name: string;
+};
+
+export class TopicPrefab extends Construct {
+  public readonly topic: Topic;
+
+  constructor(service: ServiceStack, params: CustomTopicParams) {
+    super(service, getLogicalName(TopicPrefab.name, params.name));
+
+    this.topic = new Topic(this, params.name, {
+      topicName: getResourceName(params.name, service.props),
+    });
+  }
+
+  // SNS to SQS Pattern
+  public addQueueSubs(queue: Queue): void {
+    this.topic.addSubscription(new SqsSubscription(queue));
+  }
+
+  // Mods
+  public useMod(variableName = 'DEST_TOPIC', mods: ((topic: Topic) => any)[]): Modifier {
+    return (lambda) => {
+      lambda.addEnvironment(variableName, this.topic.topicArn);
+      mods.map((fn) => fn(this.topic)(lambda));
+    };
+  }
+
+  // Class Mods
+  public static modifier = {
+    writer: (topic: Topic): Modifier => {
+      return (lambda) => {
+        topic.grantPublish(lambda);
+      };
+    },
+    // smsWriter: (): ((lambda: NodejsFunction) => void) => {
+    //   return lambda => {
+    //     lambda.addToRolePolicy(
+    //       new PolicyStatement({ effect: Effect.ALLOW, actions: ['sns:Publish'], resources: ['*'] })
+    //     );
+    //   };
+    // },
+  };
+
+  // Instance Mods
+  public useModWriter(variableName = 'DEST_TOPIC'): (lambda: NodejsFunction) => void {
+    return this.useMod(variableName, [TopicPrefab.modifier.writer]);
+  }
+}

package/prefab/networking/dns-domain-ref/index.ts

@@ -0,0 +1,32 @@
+import { HostedZone, NsRecord } from 'aws-cdk-lib/aws-route53';
+import { Construct } from 'constructs';
+
+import { ServiceStack, getLogicalName, getDomain } from '../../../common';
+
+export type DnsBaseDomainRefConstructParams = { hostedZoneNS: string };
+
+export class DnsDomainRefPrefab extends Construct {
+  /**
+   * Creates the DNS records in the parent HostedZone in order
+   * @remarks Use it only if you have the root HostedZone in another AWS account
+   * @remarks Should be only instance one per solution
+   */
+  constructor(service: ServiceStack, params: DnsBaseDomainRefConstructParams) {
+    super(service, getLogicalName(DnsDomainRefPrefab.name));
+
+    const overriddenService: ServiceStack = Object.assign({ props: { ...service.props } }, service);
+    overriddenService.props.isSingleProjectAccount = false;
+
+    if (!params.hostedZoneNS || !overriddenService.props.hostedZoneName) return;
+
+    const rootHostedZone = HostedZone.fromLookup(this, 'RootHostedZone', {
+      domainName: overriddenService.props.hostedZoneName,
+    });
+
+    const nsValues = params.hostedZoneNS.split(',');
+
+    const recordName = getDomain('', service.props);
+
+    new NsRecord(this, 'NsRecord', { recordName, values: nsValues, zone: rootHostedZone });
+  }
+}

package/prefab/networking/dns-subdomain-certificate/index.ts

@@ -0,0 +1,30 @@
+import { RemovalPolicy } from 'aws-cdk-lib';
+import { Certificate, CertificateValidation, ICertificate } from 'aws-cdk-lib/aws-certificatemanager';
+import { HostedZone } from 'aws-cdk-lib/aws-route53';
+import { Construct } from 'constructs';
+
+import { ServiceStack, getLogicalName, getDomain } from '../../../common';
+
+export type DnsSubdomainCertificateConstructParams = {
+  certificateArn?: string;
+};
+
+export class DnsSubdomainCertificatePrefab extends Construct {
+  public readonly certificate: ICertificate;
+
+  constructor(service: ServiceStack, params?: DnsSubdomainCertificateConstructParams) {
+    super(service, getLogicalName(DnsSubdomainCertificatePrefab.name));
+
+    if (params?.certificateArn) {
+      this.certificate = Certificate.fromCertificateArn(this, 'HostedZoneEnvDns', params.certificateArn);
+    } else {
+      const hostedZone = HostedZone.fromLookup(this, 'HostedZoneEnvDns', { domainName: getDomain('', service.props) });
+      this.certificate = new Certificate(this, 'Certificate', {
+        domainName: getDomain('', service.props),
+        subjectAlternativeNames: [getDomain('*', service.props)],
+        validation: CertificateValidation.fromDns(hostedZone),
+      });
+      this.certificate.applyRemovalPolicy(RemovalPolicy.DESTROY);
+    }
+  }
+}

package/prefab/networking/dns-subdomain-hosted-zone/index.ts

@@ -0,0 +1,30 @@
+import { Fn, RemovalPolicy } from 'aws-cdk-lib';
+import { HostedZone } from 'aws-cdk-lib/aws-route53';
+import { StringParameter } from 'aws-cdk-lib/aws-ssm';
+import { Construct } from 'constructs';
+
+import { ServiceStack, getLogicalName, getDomain, getResourceName } from '../../../common';
+
+export type DnsSubdomainHostedZoneParams = { isBootstrapping: boolean };
+
+export class DnsSubdomainHostedZonePrefab extends Construct {
+  public readonly hostedZoneNS!: string;
+
+  constructor(service: ServiceStack, params: DnsSubdomainHostedZoneParams) {
+    super(service, getLogicalName(DnsSubdomainHostedZonePrefab.name));
+
+    const hostedZone = new HostedZone(service, 'HostedZoneEnvDns', { zoneName: getDomain('', service.props) });
+    hostedZone.applyRemovalPolicy(RemovalPolicy.DESTROY);
+
+    const nsArray = hostedZone.hostedZoneNameServers as string[];
+    new StringParameter(this, 'HostedZoneNameServersParameter', {
+      simpleName: true,
+      parameterName: getResourceName('HostedZoneNameServers', service.props),
+      stringValue: Fn.join(',', nsArray),
+    });
+
+    if (!params.isBootstrapping) {
+      this.hostedZoneNS = StringParameter.valueFromLookup(this, getResourceName('HostedZoneNameServers', service.props));
+    }
+  }
+}

package/prefab/networking/index.ts

@@ -0,0 +1,5 @@
+export * from './dns-domain-ref';
+export * from './dns-subdomain-certificate';
+export * from './dns-subdomain-hosted-zone';
+export * from './vpc';
+export * from './waf';

package/prefab/networking/vpc/index.ts

@@ -0,0 +1,39 @@
+import { IVpc, Vpc, VpcProps } from 'aws-cdk-lib/aws-ec2';
+import { Construct } from 'constructs';
+
+import { ServiceStack, getLogicalName } from '../../../common';
+
+export type VpcPrefabParams = {
+  name: string;
+  vpcProps?: Partial<VpcProps>;
+  existingResource?: {
+    vpcId: string;
+    availabilityZones: string[];
+    publicSubnetIds: string[];
+    privateSubnetIds: string[];
+  };
+};
+
+export class VpcPrefab extends Construct {
+  public readonly vpc: IVpc;
+
+  constructor(service: ServiceStack, params: VpcPrefabParams) {
+    super(service, getLogicalName(VpcPrefab.name));
+
+    if (params.existingResource) {
+      this.vpc = Vpc.fromVpcAttributes(this, 'vpc', {
+        vpcId: params.existingResource.vpcId,
+        availabilityZones: params.existingResource.availabilityZones,
+        publicSubnetIds: params.existingResource.publicSubnetIds,
+        privateSubnetIds: params.existingResource.privateSubnetIds,
+      });
+      return this;
+    }
+
+    this.vpc = new Vpc(this, getLogicalName(params.name, 'vpc'), {
+      vpcName: params.name,
+      maxAzs: params.vpcProps?.maxAzs || 2,
+      ...params.vpcProps,
+    });
+  }
+}

package/prefab/networking/waf/index.ts

@@ -0,0 +1,49 @@
+import { CfnWebACL } from 'aws-cdk-lib/aws-wafv2';
+import { Construct } from 'constructs';
+
+import { BaseServiceProps, ServiceStack, getLogicalName, getResourceName } from '../../../common';
+
+export type WafProps = {
+  wafEnabled: boolean;
+  rules?: CfnWebACL['rules'];
+};
+
+export class WafPrefab extends Construct {
+  public readonly webACL: CfnWebACL | undefined;
+
+  constructor(service: ServiceStack, props: BaseServiceProps & WafProps) {
+    super(service, getLogicalName(WafPrefab.name));
+    const defaultRules = [
+      {
+        priority: 0,
+        name: getResourceName('BotControlRule', props),
+        overrideAction: { none: {} },
+        visibilityConfig: {
+          sampledRequestsEnabled: true,
+          cloudWatchMetricsEnabled: true,
+          metricName: getResourceName('BotControlRuleMetric', props),
+        },
+        statement: {
+          managedRuleGroupStatement: {
+            vendorName: 'AWS',
+            name: 'AWSManagedRulesBotControlRuleSet',
+          },
+        },
+      },
+    ];
+
+    // if (props.wafEnabled) {
+    this.webACL = new CfnWebACL(this, getLogicalName(WafPrefab.name, 'WebACL'), {
+      name: getResourceName('WebACL', props),
+      scope: 'CLOUDFRONT',
+      defaultAction: { allow: {} },
+      visibilityConfig: {
+        sampledRequestsEnabled: true,
+        cloudWatchMetricsEnabled: true,
+        metricName: getResourceName('WebACLMetric', props),
+      },
+      rules: props.rules || defaultRules,
+    });
+    // }
+  }
+}

package/prefab/storage/bucket/asset-bucket.ts

@@ -0,0 +1,24 @@
+import { BucketDeployment, Source } from 'aws-cdk-lib/aws-s3-deployment';
+
+import { ServiceStack } from '../../../common';
+
+import { PrivateBucketParams, PrivateBucketPrefab } from './private-bucket';
+
+export type AssetBucketParams = PrivateBucketParams & {
+  folder?: string;
+  prefix?: string;
+};
+
+export class AssetBucketPrefab extends PrivateBucketPrefab {
+  constructor(service: ServiceStack, params: AssetBucketParams) {
+    super(service, params);
+
+    if (params.folder) {
+      new BucketDeployment(this, 'DeployBucket', {
+        sources: [Source.asset(params.folder)],
+        destinationBucket: this.bucket,
+        destinationKeyPrefix: params.prefix,
+      });
+    }
+  }
+}

package/prefab/storage/bucket/index.ts

@@ -0,0 +1,2 @@
+export * from './asset-bucket';
+export * from './private-bucket';

package/prefab/storage/bucket/private-bucket.ts

@@ -0,0 +1,74 @@
+import * as awsS3 from 'aws-cdk-lib/aws-s3';
+import { RemovalPolicy } from 'aws-cdk-lib';
+import { NodejsFunction } from 'aws-cdk-lib/aws-lambda-nodejs';
+import { BucketProps } from 'aws-cdk-lib/aws-s3';
+import { SnsDestination, SqsDestination } from 'aws-cdk-lib/aws-s3-notifications';
+import { Topic } from 'aws-cdk-lib/aws-sns';
+import { Queue } from 'aws-cdk-lib/aws-sqs';
+import { Construct } from 'constructs';
+
+import { ServiceStack, getLogicalName, getBucketName, Modifier } from '../../../common';
+
+export type PrivateBucketParams = {
+  bucketName: string;
+  bucketProps?: Omit<BucketProps, 'bucketName'>;
+};
+
+export type BucketNotFilter = awsS3.NotificationKeyFilter[];
+
+export class PrivateBucketPrefab extends Construct {
+  public readonly bucket: awsS3.Bucket;
+
+  constructor(service: ServiceStack, params: PrivateBucketParams) {
+    super(service, getLogicalName(PrivateBucketPrefab.name, params.bucketName));
+
+    const defaultProps: BucketProps = {
+      encryption: awsS3.BucketEncryption.S3_MANAGED,
+      blockPublicAccess: awsS3.BlockPublicAccess.BLOCK_ALL,
+      removalPolicy: service.props.envName === 'prod' ? RemovalPolicy.RETAIN : RemovalPolicy.DESTROY,
+      autoDeleteObjects: service.props.envName !== 'prod',
+      publicReadAccess: false,
+    };
+
+    this.bucket = new awsS3.Bucket(this, getLogicalName(PrivateBucketPrefab.name, 'Bucket'), {
+      bucketName: getBucketName(params.bucketName, service.props),
+      ...defaultProps,
+      ...params.bucketProps,
+    });
+  }
+
+  public addTopicNotification(params: { topic: Topic; eventType?: awsS3.EventType; filters?: BucketNotFilter }): void {
+    this.bucket.addEventNotification(params.eventType || awsS3.EventType.OBJECT_CREATED, new SnsDestination(params.topic), ...(params.filters || []));
+  }
+
+  public addQueueNotification(params: { queue: Queue; eventType?: awsS3.EventType; filters?: BucketNotFilter }): void {
+    this.bucket.addEventNotification(params.eventType || awsS3.EventType.OBJECT_CREATED, new SqsDestination(params.queue), ...(params.filters || []));
+  }
+
+  // Mods
+  public useMod(variableName = 'BUCKET_NAME', mods: ((bucket: awsS3.Bucket) => any)[]): Modifier {
+    return (lambda: NodejsFunction): void => {
+      lambda.addEnvironment(variableName, this.bucket.bucketName);
+      mods.map((fn) => fn(this.bucket)(lambda));
+    };
+  }
+
+  // Class Mods
+  public static modifier = {
+    reader: (bucket: awsS3.Bucket): Modifier => {
+      return (lambda) => {
+        bucket.grantRead(lambda);
+      };
+    },
+    writer: (bucket: awsS3.Bucket): Modifier => {
+      return (lambda) => {
+        bucket.grantWrite(lambda);
+      };
+    },
+    delete: (bucket: awsS3.Bucket): Modifier => {
+      return (lambda) => {
+        bucket.grantDelete(lambda);
+      };
+    },
+  };
+}

package/prefab/storage/index.ts

@@ -0,0 +1 @@
+export * from './bucket';

package/prefab/utils/config/frontend-env-builder.ts

@@ -0,0 +1,30 @@
+import { StringParameter } from 'aws-cdk-lib/aws-ssm';
+import { Construct } from 'constructs';
+
+import { ServiceStack, getLogicalName, getResourceName } from '../../../common';
+
+export type FrontendEnvBuilderParams = {
+  name: string;
+  calculatedSecrets?: Record<string, string>;
+};
+
+export class FrontendEnvBuilder extends Construct {
+  public readonly secrets: Record<string, StringParameter> = {};
+
+  constructor(service: ServiceStack, params: FrontendEnvBuilderParams) {
+    super(service, getLogicalName(FrontendEnvBuilder.name, params.name));
+
+    new StringParameter(this, getLogicalName('Manual', params.name), {
+      parameterName: getResourceName('env-manual', service.props),
+      stringValue: 'REACT_ENV_EXAMPLE=example',
+    });
+
+    if (params.calculatedSecrets && Object.keys(params.calculatedSecrets).length > 0)
+      new StringParameter(this, getLogicalName('Calculated', params.name), {
+        parameterName: getResourceName('env-calculated', service.props),
+        stringValue: Object.keys(params.calculatedSecrets)
+          .map((key) => `${key}=${params.calculatedSecrets![key]}`)
+          .join('\n'),
+      });
+  }
+}

package/prefab/utils/config/index.ts

@@ -0,0 +1,3 @@
+export * from './frontend-env-builder';
+export * from './parameter-secret';
+export * from './runtime-secret';

package/prefab/utils/config/parameter-secret.ts

@@ -0,0 +1,52 @@
+import { NodejsFunction } from 'aws-cdk-lib/aws-lambda-nodejs';
+import { IStringParameter, StringParameter } from 'aws-cdk-lib/aws-ssm';
+import { Construct } from 'constructs';
+
+import { ServiceStack, SynthError, getLogicalName, getResourceName } from '../../../common';
+
+export type ParameterSecretParams = {
+  name?: string;
+  existingName?: string;
+  value?: string;
+};
+
+export class ParameterSecret extends Construct {
+  public readonly parameter!: IStringParameter;
+
+  constructor(service: ServiceStack, params: ParameterSecretParams) {
+    super(service, getLogicalName(ParameterSecret.name, params.name || params.existingName));
+
+    if (!params.existingName && !params.name) throw new SynthError('name or existingName are required');
+
+    if (params.existingName) {
+      this.parameter = StringParameter.fromStringParameterName(this, getLogicalName('param', params.existingName), params.existingName);
+    }
+
+    if (params.name) {
+      this.parameter = new StringParameter(this, getLogicalName('param', params.name), {
+        parameterName: getResourceName(params.name, service.props),
+        stringValue: params.value || 'Default value: this need to be changed',
+      });
+    }
+  }
+
+  public useModReader(variableName: string): (lambda: NodejsFunction) => void {
+    return this.useMod(variableName, [ParameterSecret.modifier.reader]);
+  }
+
+  public useMod(variableName: string, mods: ((parameter: IStringParameter) => any)[]): (lambda: NodejsFunction) => void {
+    return (lambda: NodejsFunction): void => {
+      lambda.addEnvironment(variableName, this.parameter.parameterName);
+      mods.map((fn) => fn(this.parameter)(lambda));
+    };
+  }
+
+  public static modifier = {
+    reader: (parameter: IStringParameter): ((lambda: NodejsFunction) => NodejsFunction) => {
+      return (lambda: NodejsFunction): NodejsFunction => {
+        parameter.grantRead(lambda);
+        return lambda;
+      };
+    },
+  };
+}

package/prefab/utils/config/runtime-secret.ts

@@ -0,0 +1,48 @@
+import { NodejsFunction } from 'aws-cdk-lib/aws-lambda-nodejs';
+import { ISecret, Secret } from 'aws-cdk-lib/aws-secretsmanager';
+import { Construct } from 'constructs';
+
+import { SecretConfig } from '@takumi-stack/sdk';
+
+import { ServiceStack, getLogicalName, getResourceName } from '../../../common';
+
+export type RuntimeSecretBuilderProps = {
+  secretConfig: SecretConfig;
+  fromSecret?: ISecret;
+};
+
+export class RuntimeSecret extends Construct {
+  public readonly secret: ISecret;
+  public readonly secretName: string;
+
+  constructor(service: ServiceStack, params: RuntimeSecretBuilderProps) {
+    super(service, getLogicalName(RuntimeSecret.name, params.secretConfig.name));
+
+    this.secretName = params.secretConfig.name;
+
+    this.secret = params.fromSecret
+      ? Secret.fromSecretCompleteArn(this, 'Secret', params.fromSecret.secretArn)
+      : new Secret(this, 'Secret', {
+          secretName: getResourceName(this.secretName, service.props),
+        });
+  }
+
+  public useMod(mods: ((secret: ISecret) => any)[]): (lambda: NodejsFunction) => void {
+    return (lambda: NodejsFunction): void => {
+      lambda.addEnvironment(this.secretName, this.secret.secretArn);
+      mods.map((fn) => fn(this.secret)(lambda));
+    };
+  }
+
+  public useModReader(): (lambda: NodejsFunction) => void {
+    return this.useMod([RuntimeSecret.modifier.reader]);
+  }
+
+  public static modifier = {
+    reader: (secret: ISecret): ((lambda: NodejsFunction) => void) => {
+      return (lambda: NodejsFunction): void => {
+        secret.grantRead(lambda);
+      };
+    },
+  };
+}

package/prefab/utils/deploy-pipeline/catalog/integrations/index.ts

@@ -0,0 +1 @@
+export * as Slack from './slack';

package/prefab/utils/deploy-pipeline/catalog/integrations/slack.ts

@@ -0,0 +1,23 @@
+import { ApiIntegrationInterface, EmptyObject, ApiIntegrationConfig } from '@takumi-stack/sdk';
+
+export type Interface = ApiIntegrationInterface<{
+  errorResponse: { errorCode: string; message: string };
+  response: EmptyObject;
+  pathParams: { token: string };
+  body: {
+    channel: string;
+    attachments: {
+      pretext: string;
+      fallback: string;
+      color: string;
+      fields: { title: string; value: string; short: boolean }[];
+    }[];
+  };
+  queryParams: EmptyObject;
+  headers: EmptyObject;
+}>;
+
+export const config: ApiIntegrationConfig<Interface> = {
+  method: 'POST',
+  url: 'https://hooks.slack.com/services/{token}',
+};

package/prefab/utils/deploy-pipeline/entities/index.ts

@@ -0,0 +1,23 @@
+export type PipelineNotification = {
+  detail: {
+    'execution-id': string;
+    pipeline: string;
+    state: 'FAILED';
+  };
+  additionalAttributes: {
+    failedActionCount: number;
+    failedActions: { action: string; additionalInformation: string }[];
+    failedStage: string;
+  };
+};
+
+export type SlackNotificationConfig = {
+  channel: string;
+  token: string;
+};
+
+export type SlackNotificationPayload = {
+  fallback: string;
+  color: string;
+  fields: { title: string; short: boolean; value: string }[];
+};

package/prefab/utils/deploy-pipeline/handlers/send-to-slack/handler.ts

@@ -0,0 +1,32 @@
+import { getParameter } from '@takumi-stack/sdk';
+import { SNSHandler } from 'aws-lambda';
+
+import { PipelineNotification, SlackNotificationConfig } from '../../entities';
+import { getPipelineDetail } from '../../platform/get-pipeline-detail';
+import { getSlackPayload } from '../../platform/get-slack-payload';
+import { sendToSlack } from '../../platform/send-to-slack';
+
+export const handler: SNSHandler = async (event) => {
+  await Promise.all(
+    event.Records.map(async (v) => {
+      const response: PipelineNotification = JSON.parse(v.Sns.Message);
+
+      const pipelineName = response.detail.pipeline;
+
+      const { commitId, commitMessage } = await getPipelineDetail(pipelineName, response.detail['execution-id']);
+
+      const slackPayload = getSlackPayload(pipelineName, response.detail.state, commitId, commitMessage);
+
+      if (process.env.SLACK_EXTRA_CONFIG_NAME) {
+        const slackConfig: SlackNotificationConfig[] = await getParameter(process.env.SLACK_EXTRA_CONFIG_NAME);
+        await Promise.all(slackConfig.map((sc) => sendToSlack(slackPayload, sc)));
+      } else {
+        const defaultSlackConfig: SlackNotificationConfig = {
+          channel: process.env.DEFAULT_SLACK_CHANNEL!,
+          token: await getParameter(process.env.DEFAULT_SLACK_TOKEN_PARAMETER!, true),
+        };
+        await sendToSlack(slackPayload, defaultSlackConfig);
+      }
+    })
+  );
+};