@flit/cdk-pipeline 1.4.4 → 2.0.0

package/src/publish-assets-action.ts

@@ -1,123 +1,123 @@
 import { Stack } from "aws-cdk-lib";
 import { Construct } from "constructs";
 import {
-  ActionBindOptions,
-  ActionConfig,
-  ActionProperties,
-  Artifact,
-  IAction,
-  IStage,
+	ActionBindOptions,
+	ActionConfig,
+	ActionProperties,
+	Artifact,
+	IAction,
+	IStage,
 } from "aws-cdk-lib/aws-codepipeline";
 import { BuildSpec, LinuxBuildImage, Project } from "aws-cdk-lib/aws-codebuild";
 import { CodeBuildAction } from "aws-cdk-lib/aws-codepipeline-actions";
 import {
-  AccountPrincipal,
-  CompositePrincipal,
-  PolicyDocument,
-  PolicyStatement,
-  Role,
-  ServicePrincipal,
+	AccountPrincipal,
+	CompositePrincipal,
+	PolicyDocument,
+	PolicyStatement,
+	Role,
+	ServicePrincipal,
 } from "aws-cdk-lib/aws-iam";
 import { IRuleTarget, RuleProps, Rule } from "aws-cdk-lib/aws-events";
 import * as path from "path";
 
 export interface PublishAssetsActionProps {
-  readonly actionName: string;
-  readonly input: Artifact;
-  readonly manifestPath: string;
-  readonly runOrder?: number;
+	readonly actionName: string;
+	readonly input: Artifact;
+	readonly manifestPath: string;
+	readonly runOrder?: number;
 }
 
 export class PublishAssetsAction extends Construct implements IAction {
-  public readonly actionProperties: ActionProperties;
+	public readonly actionProperties: ActionProperties;
 
-  bound(
-    scope: Construct,
-    stage: IStage,
-    options: ActionBindOptions,
-  ): ActionConfig {
-    throw new Error(`Method not implemented.${!scope && !stage! && options}`);
-  }
+	bound(
+		scope: Construct,
+		stage: IStage,
+		options: ActionBindOptions,
+	): ActionConfig {
+		throw new Error(`Method not implemented.${!scope && !stage! && options}`);
+	}
 
-  bind(
-    scope: Construct,
-    stage: IStage,
-    options: ActionBindOptions,
-  ): ActionConfig {
-    throw new Error(`Method not implemented.${!scope && !stage! && options}`);
-  }
+	bind(
+		scope: Construct,
+		stage: IStage,
+		options: ActionBindOptions,
+	): ActionConfig {
+		throw new Error(`Method not implemented.${!scope && !stage! && options}`);
+	}
 
-  onStateChange(
-    name: string,
-    target?: IRuleTarget | undefined,
-    options?: RuleProps | undefined,
-  ): Rule {
-    throw new Error(`Method not implemented.${!name && !target! && options}`);
-  }
+	onStateChange(
+		name: string,
+		target?: IRuleTarget | undefined,
+		options?: RuleProps | undefined,
+	): Rule {
+		throw new Error(`Method not implemented.${!name && !target! && options}`);
+	}
 
-  constructor(scope: Construct, id: string, props: PublishAssetsActionProps) {
-    super(scope, id);
-    const codeBuild = new CodeBuildAction({
-      ...props,
-      input: props.input,
-      project: new Project(this, id, {
-        environment: {
-          buildImage: LinuxBuildImage.AMAZON_LINUX_2_5,
-        },
-        role: new Role(this, "UpdatePipelineCodeCuildRole", {
-          assumedBy: new CompositePrincipal(
-            new ServicePrincipal("codebuild.amazonaws.com"),
-            new AccountPrincipal(Stack.of(this).account),
-          ),
-          inlinePolicies: {
-            selfMutation: new PolicyDocument({
-              statements: [
-                new PolicyStatement({
-                  actions: ["sts:AssumeRole"],
-                  resources: [`arn:*:iam::${Stack.of(this).account}:role/*`],
-                  conditions: {
-                    "ForAnyValue:StringEquals": {
-                      "iam:ResourceTag/aws-cdk:bootstrap-role": [
-                        "image-publishing",
-                        "file-publishing",
-                        "deploy",
-                      ],
-                    },
-                  },
-                }),
-              ],
-            }),
-          },
-        }),
-        buildSpec: BuildSpec.fromObject({
-          version: "0.2",
-          phases: {
-            install: {
-              "runtime-versions": {
-                nodejs: "latest",
-              },
-              commands: ["npm i -g @flit/publish-cdk-assets@latest"],
-            },
-            build: {
-              commands: `pca ${
-                props.manifestPath ? path.normalize(props.manifestPath) : "."
-              }`,
-            },
-          },
-        }),
-      }),
-    });
+	constructor(scope: Construct, id: string, props: PublishAssetsActionProps) {
+		super(scope, id);
+		const codeBuild = new CodeBuildAction({
+			...props,
+			input: props.input,
+			project: new Project(this, id, {
+				environment: {
+					buildImage: LinuxBuildImage.AMAZON_LINUX_2_5,
+				},
+				role: new Role(this, "UpdatePipelineCodeCuildRole", {
+					assumedBy: new CompositePrincipal(
+						new ServicePrincipal("codebuild.amazonaws.com"),
+						new AccountPrincipal(Stack.of(this).account),
+					),
+					inlinePolicies: {
+						selfMutation: new PolicyDocument({
+							statements: [
+								new PolicyStatement({
+									actions: ["sts:AssumeRole"],
+									resources: [`arn:*:iam::${Stack.of(this).account}:role/*`],
+									conditions: {
+										"ForAnyValue:StringEquals": {
+											"iam:ResourceTag/aws-cdk:bootstrap-role": [
+												"image-publishing",
+												"file-publishing",
+												"deploy",
+											],
+										},
+									},
+								}),
+							],
+						}),
+					},
+				}),
+				buildSpec: BuildSpec.fromObject({
+					version: "0.2",
+					phases: {
+						install: {
+							"runtime-versions": {
+								nodejs: "latest",
+							},
+							commands: ["npm i -g @flit/publish-cdk-assets@latest"],
+						},
+						build: {
+							commands: `pca ${
+								props.manifestPath ? path.normalize(props.manifestPath) : "."
+							}`,
+						},
+					},
+				}),
+			}),
+		});
 
-    this.actionProperties = codeBuild.actionProperties;
-    this.bind = (
-      scope: Construct,
-      stage: IStage,
-      options: ActionBindOptions,
-    ): ActionConfig => codeBuild.bind(scope, stage, options);
-    this.onStateChange = (
-      name: string,
-      target?: IRuleTarget,
-      options?: RuleProps,
-    ): Rule => codeBuild.onStateChange(name, target, options);
-  }
+		this.actionProperties = codeBuild.actionProperties;
+		this.bind = (
+			scope: Construct,
+			stage: IStage,
+			options: ActionBindOptions,
+		): ActionConfig => codeBuild.bind(scope, stage, options);
+		this.onStateChange = (
+			name: string,
+			target?: IRuleTarget,
+			options?: RuleProps,
+		): Rule => codeBuild.onStateChange(name, target, options);
+	}
 }

package/src/s3-source-segment.ts

@@ -1,7 +1,7 @@
 import { IAction } from "aws-cdk-lib/aws-codepipeline";
 import {
-  S3SourceAction,
-  S3Trigger,
+	S3SourceAction,
+	S3Trigger,
 } from "aws-cdk-lib/aws-codepipeline-actions";
 import { SecretValue } from "aws-cdk-lib";
 import { IBucket } from "aws-cdk-lib/aws-s3";
@@ -12,51 +12,51 @@ import { SegmentConstructed } from "./segment";
 import { SourceSegment, SourceSegmentProps } from "./source-segment";
 
 export interface S3SourceSegmentProps extends SourceSegmentProps {
-  readonly oauthToken: SecretValue;
-  readonly bucket: IBucket;
-  readonly bucketKey: string;
-  readonly trigger?: S3Trigger;
-  readonly variablesNamespace?: string;
+	readonly oauthToken: SecretValue;
+	readonly bucket: IBucket;
+	readonly bucketKey: string;
+	readonly trigger?: S3Trigger;
+	readonly variablesNamespace?: string;
 }
 
 /**
  * @category Segments
  */
 export class S3SourceSegment extends SourceSegment {
-  private props: S3SourceSegmentProps;
-  constructor(props: S3SourceSegmentProps) {
-    super(props);
-    this.props = props;
-  }
-  construct(scope: Pipeline): SegmentConstructed {
-    const name = `${this.props.bucket}-${this.props.bucketKey}`;
+	private props: S3SourceSegmentProps;
+	constructor(props: S3SourceSegmentProps) {
+		super(props);
+		this.props = props;
+	}
+	construct(scope: Pipeline): SegmentConstructed {
+		const name = `${this.props.bucket}-${this.props.bucketKey}`;
 
-    return new S3SourceSegmentConstructed(scope, name, {
-      ...this.props,
-      actionName: name,
-    });
-  }
+		return new S3SourceSegmentConstructed(scope, name, {
+			...this.props,
+			actionName: name,
+		});
+	}
 }
 
 export interface S3SourceSegmentConstructedProps {
-  readonly output: Artifact;
-  readonly actionName: string;
-  readonly bucket: IBucket;
-  readonly bucketKey: string;
-  readonly trigger?: S3Trigger;
-  readonly variablesNamespace?: string;
+	readonly output: Artifact;
+	readonly actionName: string;
+	readonly bucket: IBucket;
+	readonly bucketKey: string;
+	readonly trigger?: S3Trigger;
+	readonly variablesNamespace?: string;
 }
 
 export class S3SourceSegmentConstructed extends SegmentConstructed {
-  readonly name: string;
-  readonly actions: IAction[];
-  constructor(
-    scope: Pipeline,
-    id: string,
-    props: S3SourceSegmentConstructedProps,
-  ) {
-    super(scope, id);
-    this.name = "Source";
-    this.actions = [new S3SourceAction(props)];
-  }
+	readonly name: string;
+	readonly actions: IAction[];
+	constructor(
+		scope: Pipeline,
+		id: string,
+		props: S3SourceSegmentConstructedProps,
+	) {
+		super(scope, id);
+		this.name = "Source";
+		this.actions = [new S3SourceAction(props)];
+	}
 }

package/src/segment.ts

@@ -6,32 +6,32 @@ import { Artifact } from "./artifact";
 import { Pipeline } from "./pipeline";
 
 export interface SegmentProps {
-  readonly input?: Artifact | Artifact[];
-  readonly output?: Artifact | Artifact[];
+	readonly input?: Artifact | Artifact[];
+	readonly output?: Artifact | Artifact[];
 }
 
 export abstract class Segment {
-  readonly isSource: boolean = false;
-  readonly isPipeline: boolean = false;
-  readonly dependencies?: Stack[];
-  readonly inputs: Artifact[] = [];
-  readonly outputs: Artifact[] = [];
-  constructor(props: SegmentProps) {
-    if (props.input) {
-      this.inputs = Array.isArray(props.input) ? props.input : [props.input];
-      this.inputs.forEach((artifact) => artifact.consume(this), this);
-    }
-    if (props.output) {
-      this.outputs = Array.isArray(props.output)
-        ? props.output
-        : [props.output];
-      this.outputs.forEach((artifact) => artifact.produce(this), this);
-    }
-  }
-  abstract construct(scope: Pipeline): SegmentConstructed;
+	readonly isSource: boolean = false;
+	readonly isPipeline: boolean = false;
+	readonly dependencies?: Stack[];
+	readonly inputs: Artifact[] = [];
+	readonly outputs: Artifact[] = [];
+	constructor(props: SegmentProps) {
+		if (props.input) {
+			this.inputs = Array.isArray(props.input) ? props.input : [props.input];
+			this.inputs.forEach((artifact) => artifact.consume(this), this);
+		}
+		if (props.output) {
+			this.outputs = Array.isArray(props.output)
+				? props.output
+				: [props.output];
+			this.outputs.forEach((artifact) => artifact.produce(this), this);
+		}
+	}
+	abstract construct(scope: Pipeline): SegmentConstructed;
 }
 
 export abstract class SegmentConstructed extends Construct {
-  readonly name: string = "";
-  readonly actions: IAction[] = [];
+	readonly name: string = "";
+	readonly actions: IAction[] = [];
 }

package/src/source-segment.ts

@@ -2,13 +2,13 @@ import { Artifact } from "./artifact";
 import { Segment } from "./segment";
 
 export interface SourceSegmentProps {
-  readonly output: Artifact;
+	readonly output: Artifact;
 }
 
 export abstract class SourceSegment extends Segment {
-  readonly isSource = true;
+	readonly isSource = true;
 }
 
 export function isSource(item: Segment): item is SourceSegment {
-  return item.isSource;
+	return item.isSource;
 }