codepipeline-event-notifier 0.2.8 → 0.3.1

package/lib/funcs/notifier.lambda.js

@@ -5,6 +5,7 @@ const client_codepipeline_1 = require("@aws-sdk/client-codepipeline");
 const client_sns_1 = require("@aws-sdk/client-sns");
 const strict_env_resolver_1 = require("strict-env-resolver");
 const notifier_predicates_1 = require("./notifier-predicates");
+const target_pipeline_predicates_1 = require("./target-pipeline-predicates");
 /**
  * SNS client used to publish notifications.
  */
@@ -79,9 +80,31 @@ const waitPipelineExecution = async (params) => {
         note: 'Waiting timed out before terminal state.',
     });
 };
+/**
+ * Returns whether the pipeline in the event matches the configured tag filters.
+ *
+ * @param event EventBridge STARTED event
+ * @param pipelineName pipeline name from the event detail
+ * @returns true when the pipeline should be notified
+ */
+const isTargetPipelineEvent = async (event, pipelineName) => {
+    const tagFilters = (0, target_pipeline_predicates_1.parseTargetPipelineTags)(mustEnv('TARGET_PIPELINE_TAGS'));
+    const pipelineArn = (0, target_pipeline_predicates_1.resolvePipelineArn)(event.resources, event.region, event.account, pipelineName);
+    if (!pipelineArn) {
+        throw new Error('Unable to resolve pipeline ARN for tag lookup');
+    }
+    const allowedArns = (0, target_pipeline_predicates_1.parseAllowedPipelineArns)(process.env.TARGET_PIPELINE_ARNS);
+    if (!(0, target_pipeline_predicates_1.isAllowedPipelineArn)(pipelineArn, allowedArns)) {
+        return false;
+    }
+    const listed = await codepipeline.send(new client_codepipeline_1.ListTagsForResourceCommand({
+        resourceArn: pipelineArn,
+    }));
+    return (0, target_pipeline_predicates_1.matchesTargetPipelineTags)((0, target_pipeline_predicates_1.toPipelineTagMap)(listed.tags), tagFilters);
+};
 /**
  * Lambda handler triggered by EventBridge when a pipeline execution transitions to STARTED.
- * It waits for the execution status until it reaches a terminal state or times out.
+ * It ignores pipelines that do not match `TARGET_PIPELINE_TAGS` (and optional `TARGET_PIPELINE_ARNS`), then waits for a terminal state.
  */
 const handler = async (event) => {
     const topicArn = mustEnv('SNS_TOPIC_ARN');
@@ -96,6 +119,9 @@ const handler = async (event) => {
         });
         return;
     }
+    if (!await isTargetPipelineEvent(event, identity.pipelineName)) {
+        return;
+    }
     const waitIntervalSeconds = strict_env_resolver_1.StrictEnvResolver.resolve('WAIT_INTERVAL_SECONDS', strict_env_resolver_1.StrictEnvType.Number, { default: 10 });
     const maxWaitMinutes = strict_env_resolver_1.StrictEnvResolver.resolve('MAX_WAIT_MINUTES', strict_env_resolver_1.StrictEnvType.Number, { default: 14 });
     await waitPipelineExecution({
@@ -108,4 +134,4 @@ const handler = async (event) => {
     });
 };
 exports.handler = handler;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"notifier.lambda.js","sourceRoot":"","sources":["../../src/funcs/notifier.lambda.ts"],"names":[],"mappings":"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","sourcesContent":["import { CodePipelineClient, GetPipelineExecutionCommand } from '@aws-sdk/client-codepipeline';\nimport { PublishCommand, SNSClient } from '@aws-sdk/client-sns';\nimport type { EventBridgeEvent } from 'aws-lambda';\nimport { StrictEnvResolver, StrictEnvType } from 'strict-env-resolver';\nimport {\n  isTerminalExecutionStatus,\n  normalizeExecutionStatus,\n  resolvePipelineExecutionIdentity,\n} from './notifier-predicates';\n\n/**\n * EventBridge detail payload for CodePipeline execution state-change events.\n */\ntype CodePipelineExecutionStartedDetail = {\n  'pipeline'?: string;\n  'state'?: string;\n  'version'?: string;\n  'execution-id'?: string;\n};\n\n/**\n * EventBridge event for CodePipeline execution state-change notifications.\n */\ntype CodePipelineExecutionStartedEvent = EventBridgeEvent<\n  'CodePipeline Pipeline Execution State Change',\n  CodePipelineExecutionStartedDetail\n>;\n\n/**\n * SNS client used to publish notifications.\n */\nconst sns = new SNSClient({});\n\n/**\n * CodePipeline client used to wait for execution state changes.\n */\nconst codepipeline = new CodePipelineClient({});\n\n/**\n * Reads a required environment variable.\n */\nconst mustEnv = (name: string): string => StrictEnvResolver.resolve(name, StrictEnvType.String, { trim: true });\n\n/**\n * Sleeps for the specified number of milliseconds.\n */\nconst sleep = (ms: number): Promise<void> => new Promise((resolve) => setTimeout(resolve, ms));\n\n/**\n * Publishes a JSON payload to the given SNS topic ARN.\n */\nconst publish = async (topicArn: string, payload: unknown): Promise<void> => {\n  await sns.send(new PublishCommand({\n    TopicArn: topicArn,\n    Message: JSON.stringify(payload),\n  }));\n};\n\n/**\n * Waits on a CodePipeline execution and publishes notifications whenever the execution status changes.\n */\nconst waitPipelineExecution = async (params: {\n  topicArn: string;\n  pipelineName: string;\n  executionId: string;\n  waitIntervalSeconds: number;\n  maxWaitMinutes: number;\n  startEvent: CodePipelineExecutionStartedEvent;\n}): Promise<void> => {\n  const {\n    topicArn,\n    pipelineName,\n    executionId,\n    waitIntervalSeconds,\n    maxWaitMinutes,\n    startEvent,\n  } = params;\n\n  const deadline = Date.now() + maxWaitMinutes * 60_000;\n  let lastStatus: string | undefined;\n\n  // 最初に STARTED を通知（EventBridge由来）\n  await publish(topicArn, {\n    type: 'codepipeline.execution',\n    phase: 'eventbridge',\n    pipelineName,\n    executionId,\n    observedState: startEvent.detail?.state ?? 'STARTED',\n    observedAt: new Date().toISOString(),\n    event: startEvent,\n  });\n\n  while (Date.now() < deadline) {\n    const res = await codepipeline.send(new GetPipelineExecutionCommand({\n      pipelineName,\n      pipelineExecutionId: executionId,\n    }));\n\n    const status = normalizeExecutionStatus(res.pipelineExecution?.status);\n    if (status !== lastStatus) {\n      lastStatus = status;\n      await publish(topicArn, {\n        type: 'codepipeline.execution',\n        phase: 'wait',\n        pipelineName,\n        executionId,\n        observedState: status,\n        observedAt: new Date().toISOString(),\n      });\n    }\n\n    if (isTerminalExecutionStatus(status)) {\n      return;\n    }\n\n    await sleep(waitIntervalSeconds * 1000);\n  }\n\n  await publish(topicArn, {\n    type: 'codepipeline.execution',\n    phase: 'wait',\n    pipelineName,\n    executionId,\n    observedState: lastStatus ?? 'UNKNOWN',\n    observedAt: new Date().toISOString(),\n    note: 'Waiting timed out before terminal state.',\n  });\n};\n\n/**\n * Lambda handler triggered by EventBridge when a pipeline execution transitions to STARTED.\n * It waits for the execution status until it reaches a terminal state or times out.\n */\nexport const handler = async (event: CodePipelineExecutionStartedEvent): Promise<void> => {\n  const topicArn = mustEnv('SNS_TOPIC_ARN');\n  const identity = resolvePipelineExecutionIdentity(\n    event.detail?.pipeline,\n    event.detail?.['execution-id'],\n  );\n\n  if (!identity) {\n    await publish(topicArn, {\n      type: 'codepipeline.execution',\n      phase: 'eventbridge',\n      observedAt: new Date().toISOString(),\n      note: 'Missing pipelineName or executionId in event.detail',\n      event,\n    });\n    return;\n  }\n\n  const waitIntervalSeconds = StrictEnvResolver.resolve('WAIT_INTERVAL_SECONDS', StrictEnvType.Number, { default: 10 });\n  const maxWaitMinutes = StrictEnvResolver.resolve('MAX_WAIT_MINUTES', StrictEnvType.Number, { default: 14 });\n\n  await waitPipelineExecution({\n    topicArn,\n    pipelineName: identity.pipelineName,\n    executionId: identity.executionId,\n    waitIntervalSeconds: waitIntervalSeconds > 0 ? waitIntervalSeconds : 10,\n    maxWaitMinutes: maxWaitMinutes > 0 ? maxWaitMinutes : 14,\n    startEvent: event,\n  });\n};\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"notifier.lambda.js","sourceRoot":"","sources":["../../src/funcs/notifier.lambda.ts"],"names":[],"mappings":";;;AAAA,sEAA2H;AAC3H,oDAAgE;AAEhE,6DAAuE;AACvE,+DAI+B;AAC/B,6EAOsC;AAoBtC;;GAEG;AACH,MAAM,GAAG,GAAG,IAAI,sBAAS,CAAC,EAAE,CAAC,CAAC;AAE9B;;GAEG;AACH,MAAM,YAAY,GAAG,IAAI,wCAAkB,CAAC,EAAE,CAAC,CAAC;AAEhD;;GAEG;AACH,MAAM,OAAO,GAAG,CAAC,IAAY,EAAU,EAAE,CAAC,uCAAiB,CAAC,OAAO,CAAC,IAAI,EAAE,mCAAa,CAAC,MAAM,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;AAEhH;;GAEG;AACH,MAAM,KAAK,GAAG,CAAC,EAAU,EAAiB,EAAE,CAAC,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,CAAC;AAE/F;;GAEG;AACH,MAAM,OAAO,GAAG,KAAK,EAAE,QAAgB,EAAE,OAAgB,EAAiB,EAAE;IAC1E,MAAM,GAAG,CAAC,IAAI,CAAC,IAAI,2BAAc,CAAC;QAChC,QAAQ,EAAE,QAAQ;QAClB,OAAO,EAAE,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC;KACjC,CAAC,CAAC,CAAC;AACN,CAAC,CAAC;AAEF;;GAEG;AACH,MAAM,qBAAqB,GAAG,KAAK,EAAE,MAOpC,EAAiB,EAAE;IAClB,MAAM,EACJ,QAAQ,EACR,YAAY,EACZ,WAAW,EACX,mBAAmB,EACnB,cAAc,EACd,UAAU,GACX,GAAG,MAAM,CAAC;IAEX,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,cAAc,GAAG,MAAM,CAAC;IACtD,IAAI,UAA8B,CAAC;IAEnC,iCAAiC;IACjC,MAAM,OAAO,CAAC,QAAQ,EAAE;QACtB,IAAI,EAAE,wBAAwB;QAC9B,KAAK,EAAE,aAAa;QACpB,YAAY;QACZ,WAAW;QACX,aAAa,EAAE,UAAU,CAAC,MAAM,EAAE,KAAK,IAAI,SAAS;QACpD,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;QACpC,KAAK,EAAE,UAAU;KAClB,CAAC,CAAC;IAEH,OAAO,IAAI,CAAC,GAAG,EAAE,GAAG,QAAQ,EAAE,CAAC;QAC7B,MAAM,GAAG,GAAG,MAAM,YAAY,CAAC,IAAI,CAAC,IAAI,iDAA2B,CAAC;YAClE,YAAY;YACZ,mBAAmB,EAAE,WAAW;SACjC,CAAC,CAAC,CAAC;QAEJ,MAAM,MAAM,GAAG,IAAA,8CAAwB,EAAC,GAAG,CAAC,iBAAiB,EAAE,MAAM,CAAC,CAAC;QACvE,IAAI,MAAM,KAAK,UAAU,EAAE,CAAC;YAC1B,UAAU,GAAG,MAAM,CAAC;YACpB,MAAM,OAAO,CAAC,QAAQ,EAAE;gBACtB,IAAI,EAAE,wBAAwB;gBAC9B,KAAK,EAAE,MAAM;gBACb,YAAY;gBACZ,WAAW;gBACX,aAAa,EAAE,MAAM;gBACrB,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;aACrC,CAAC,CAAC;QACL,CAAC;QAED,IAAI,IAAA,+CAAyB,EAAC,MAAM,CAAC,EAAE,CAAC;YACtC,OAAO;QACT,CAAC;QAED,MAAM,KAAK,CAAC,mBAAmB,GAAG,IAAI,CAAC,CAAC;IAC1C,CAAC;IAED,MAAM,OAAO,CAAC,QAAQ,EAAE;QACtB,IAAI,EAAE,wBAAwB;QAC9B,KAAK,EAAE,MAAM;QACb,YAAY;QACZ,WAAW;QACX,aAAa,EAAE,UAAU,IAAI,SAAS;QACtC,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;QACpC,IAAI,EAAE,0CAA0C;KACjD,CAAC,CAAC;AACL,CAAC,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,qBAAqB,GAAG,KAAK,EACjC,KAAwC,EACxC,YAAoB,EACF,EAAE;IACpB,MAAM,UAAU,GAAG,IAAA,oDAAuB,EAAC,OAAO,CAAC,sBAAsB,CAAC,CAAC,CAAC;IAC5E,MAAM,WAAW,GAAG,IAAA,+CAAkB,EACpC,KAAK,CAAC,SAAS,EACf,KAAK,CAAC,MAAM,EACZ,KAAK,CAAC,OAAO,EACb,YAAY,CACb,CAAC;IACF,IAAI,CAAC,WAAW,EAAE,CAAC;QACjB,MAAM,IAAI,KAAK,CAAC,+CAA+C,CAAC,CAAC;IACnE,CAAC;IAED,MAAM,WAAW,GAAG,IAAA,qDAAwB,EAAC,OAAO,CAAC,GAAG,CAAC,oBAAoB,CAAC,CAAC;IAC/E,IAAI,CAAC,IAAA,iDAAoB,EAAC,WAAW,EAAE,WAAW,CAAC,EAAE,CAAC;QACpD,OAAO,KAAK,CAAC;IACf,CAAC;IAED,MAAM,MAAM,GAAG,MAAM,YAAY,CAAC,IAAI,CAAC,IAAI,gDAA0B,CAAC;QACpE,WAAW,EAAE,WAAW;KACzB,CAAC,CAAC,CAAC;IAEJ,OAAO,IAAA,sDAAyB,EAAC,IAAA,6CAAgB,EAAC,MAAM,CAAC,IAAI,CAAC,EAAE,UAAU,CAAC,CAAC;AAC9E,CAAC,CAAC;AAEF;;;GAGG;AACI,MAAM,OAAO,GAAG,KAAK,EAAE,KAAwC,EAAiB,EAAE;IACvF,MAAM,QAAQ,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;IAC1C,MAAM,QAAQ,GAAG,IAAA,sDAAgC,EAC/C,KAAK,CAAC,MAAM,EAAE,QAAQ,EACtB,KAAK,CAAC,MAAM,EAAE,CAAC,cAAc,CAAC,CAC/B,CAAC;IAEF,IAAI,CAAC,QAAQ,EAAE,CAAC;QACd,MAAM,OAAO,CAAC,QAAQ,EAAE;YACtB,IAAI,EAAE,wBAAwB;YAC9B,KAAK,EAAE,aAAa;YACpB,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACpC,IAAI,EAAE,qDAAqD;YAC3D,KAAK;SACN,CAAC,CAAC;QACH,OAAO;IACT,CAAC;IAED,IAAI,CAAC,MAAM,qBAAqB,CAAC,KAAK,EAAE,QAAQ,CAAC,YAAY,CAAC,EAAE,CAAC;QAC/D,OAAO;IACT,CAAC;IAED,MAAM,mBAAmB,GAAG,uCAAiB,CAAC,OAAO,CAAC,uBAAuB,EAAE,mCAAa,CAAC,MAAM,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC,CAAC;IACtH,MAAM,cAAc,GAAG,uCAAiB,CAAC,OAAO,CAAC,kBAAkB,EAAE,mCAAa,CAAC,MAAM,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC,CAAC;IAE5G,MAAM,qBAAqB,CAAC;QAC1B,QAAQ;QACR,YAAY,EAAE,QAAQ,CAAC,YAAY;QACnC,WAAW,EAAE,QAAQ,CAAC,WAAW;QACjC,mBAAmB,EAAE,mBAAmB,GAAG,CAAC,CAAC,CAAC,CAAC,mBAAmB,CAAC,CAAC,CAAC,EAAE;QACvE,cAAc,EAAE,cAAc,GAAG,CAAC,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,EAAE;QACxD,UAAU,EAAE,KAAK;KAClB,CAAC,CAAC;AACL,CAAC,CAAC;AAjCW,QAAA,OAAO,WAiClB","sourcesContent":["import { CodePipelineClient, GetPipelineExecutionCommand, ListTagsForResourceCommand } from '@aws-sdk/client-codepipeline';\nimport { PublishCommand, SNSClient } from '@aws-sdk/client-sns';\nimport type { EventBridgeEvent } from 'aws-lambda';\nimport { StrictEnvResolver, StrictEnvType } from 'strict-env-resolver';\nimport {\n  isTerminalExecutionStatus,\n  normalizeExecutionStatus,\n  resolvePipelineExecutionIdentity,\n} from './notifier-predicates';\nimport {\n  isAllowedPipelineArn,\n  matchesTargetPipelineTags,\n  parseAllowedPipelineArns,\n  parseTargetPipelineTags,\n  resolvePipelineArn,\n  toPipelineTagMap,\n} from './target-pipeline-predicates';\n\n/**\n * EventBridge detail payload for CodePipeline execution state-change events.\n */\ntype CodePipelineExecutionStartedDetail = {\n  'pipeline'?: string;\n  'state'?: string;\n  'version'?: string;\n  'execution-id'?: string;\n};\n\n/**\n * EventBridge event for CodePipeline execution state-change notifications.\n */\ntype CodePipelineExecutionStartedEvent = EventBridgeEvent<\n  'CodePipeline Pipeline Execution State Change',\n  CodePipelineExecutionStartedDetail\n>;\n\n/**\n * SNS client used to publish notifications.\n */\nconst sns = new SNSClient({});\n\n/**\n * CodePipeline client used to wait for execution state changes.\n */\nconst codepipeline = new CodePipelineClient({});\n\n/**\n * Reads a required environment variable.\n */\nconst mustEnv = (name: string): string => StrictEnvResolver.resolve(name, StrictEnvType.String, { trim: true });\n\n/**\n * Sleeps for the specified number of milliseconds.\n */\nconst sleep = (ms: number): Promise<void> => new Promise((resolve) => setTimeout(resolve, ms));\n\n/**\n * Publishes a JSON payload to the given SNS topic ARN.\n */\nconst publish = async (topicArn: string, payload: unknown): Promise<void> => {\n  await sns.send(new PublishCommand({\n    TopicArn: topicArn,\n    Message: JSON.stringify(payload),\n  }));\n};\n\n/**\n * Waits on a CodePipeline execution and publishes notifications whenever the execution status changes.\n */\nconst waitPipelineExecution = async (params: {\n  topicArn: string;\n  pipelineName: string;\n  executionId: string;\n  waitIntervalSeconds: number;\n  maxWaitMinutes: number;\n  startEvent: CodePipelineExecutionStartedEvent;\n}): Promise<void> => {\n  const {\n    topicArn,\n    pipelineName,\n    executionId,\n    waitIntervalSeconds,\n    maxWaitMinutes,\n    startEvent,\n  } = params;\n\n  const deadline = Date.now() + maxWaitMinutes * 60_000;\n  let lastStatus: string | undefined;\n\n  // 最初に STARTED を通知（EventBridge由来）\n  await publish(topicArn, {\n    type: 'codepipeline.execution',\n    phase: 'eventbridge',\n    pipelineName,\n    executionId,\n    observedState: startEvent.detail?.state ?? 'STARTED',\n    observedAt: new Date().toISOString(),\n    event: startEvent,\n  });\n\n  while (Date.now() < deadline) {\n    const res = await codepipeline.send(new GetPipelineExecutionCommand({\n      pipelineName,\n      pipelineExecutionId: executionId,\n    }));\n\n    const status = normalizeExecutionStatus(res.pipelineExecution?.status);\n    if (status !== lastStatus) {\n      lastStatus = status;\n      await publish(topicArn, {\n        type: 'codepipeline.execution',\n        phase: 'wait',\n        pipelineName,\n        executionId,\n        observedState: status,\n        observedAt: new Date().toISOString(),\n      });\n    }\n\n    if (isTerminalExecutionStatus(status)) {\n      return;\n    }\n\n    await sleep(waitIntervalSeconds * 1000);\n  }\n\n  await publish(topicArn, {\n    type: 'codepipeline.execution',\n    phase: 'wait',\n    pipelineName,\n    executionId,\n    observedState: lastStatus ?? 'UNKNOWN',\n    observedAt: new Date().toISOString(),\n    note: 'Waiting timed out before terminal state.',\n  });\n};\n\n/**\n * Returns whether the pipeline in the event matches the configured tag filters.\n *\n * @param event EventBridge STARTED event\n * @param pipelineName pipeline name from the event detail\n * @returns true when the pipeline should be notified\n */\nconst isTargetPipelineEvent = async (\n  event: CodePipelineExecutionStartedEvent,\n  pipelineName: string,\n): Promise<boolean> => {\n  const tagFilters = parseTargetPipelineTags(mustEnv('TARGET_PIPELINE_TAGS'));\n  const pipelineArn = resolvePipelineArn(\n    event.resources,\n    event.region,\n    event.account,\n    pipelineName,\n  );\n  if (!pipelineArn) {\n    throw new Error('Unable to resolve pipeline ARN for tag lookup');\n  }\n\n  const allowedArns = parseAllowedPipelineArns(process.env.TARGET_PIPELINE_ARNS);\n  if (!isAllowedPipelineArn(pipelineArn, allowedArns)) {\n    return false;\n  }\n\n  const listed = await codepipeline.send(new ListTagsForResourceCommand({\n    resourceArn: pipelineArn,\n  }));\n\n  return matchesTargetPipelineTags(toPipelineTagMap(listed.tags), tagFilters);\n};\n\n/**\n * Lambda handler triggered by EventBridge when a pipeline execution transitions to STARTED.\n * It ignores pipelines that do not match `TARGET_PIPELINE_TAGS` (and optional `TARGET_PIPELINE_ARNS`), then waits for a terminal state.\n */\nexport const handler = async (event: CodePipelineExecutionStartedEvent): Promise<void> => {\n  const topicArn = mustEnv('SNS_TOPIC_ARN');\n  const identity = resolvePipelineExecutionIdentity(\n    event.detail?.pipeline,\n    event.detail?.['execution-id'],\n  );\n\n  if (!identity) {\n    await publish(topicArn, {\n      type: 'codepipeline.execution',\n      phase: 'eventbridge',\n      observedAt: new Date().toISOString(),\n      note: 'Missing pipelineName or executionId in event.detail',\n      event,\n    });\n    return;\n  }\n\n  if (!await isTargetPipelineEvent(event, identity.pipelineName)) {\n    return;\n  }\n\n  const waitIntervalSeconds = StrictEnvResolver.resolve('WAIT_INTERVAL_SECONDS', StrictEnvType.Number, { default: 10 });\n  const maxWaitMinutes = StrictEnvResolver.resolve('MAX_WAIT_MINUTES', StrictEnvType.Number, { default: 14 });\n\n  await waitPipelineExecution({\n    topicArn,\n    pipelineName: identity.pipelineName,\n    executionId: identity.executionId,\n    waitIntervalSeconds: waitIntervalSeconds > 0 ? waitIntervalSeconds : 10,\n    maxWaitMinutes: maxWaitMinutes > 0 ? maxWaitMinutes : 14,\n    startEvent: event,\n  });\n};\n"]}

package/lib/funcs/target-pipeline-predicates.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Tag filter used to decide whether a CodePipeline should be notified.
+ */
+export interface PipelineTagFilter {
+    /**
+     * Tag key that must be present on the pipeline.
+     */
+    readonly key: string;
+    /**
+     * Accepted values for {@link key}. Matching is OR within this list.
+     */
+    readonly values: readonly string[];
+}
+/**
+ * Returns whether `value` is a non-empty list of `{ key, values }` tag filters.
+ *
+ * @param value unknown JSON value
+ * @returns true when the value can be used as tag filters
+ */
+export declare const isPipelineTagFilterList: (value: unknown) => value is PipelineTagFilter[];
+/**
+ * Returns whether `value` is a single tag filter with a non-empty key and values.
+ *
+ * @param value unknown JSON value
+ * @returns true when the value is a tag filter
+ */
+export declare const isPipelineTagFilter: (value: unknown) => value is PipelineTagFilter;
+/**
+ * Parses `TARGET_PIPELINE_TAGS` JSON into tag filters.
+ *
+ * @param raw JSON string from the environment
+ * @returns normalized tag filters
+ * @throws when the JSON is invalid or not a tag-filter list
+ */
+export declare const parseTargetPipelineTags: (raw: string) => PipelineTagFilter[];
+/**
+ * Trims keys/values and rejects duplicate keys.
+ *
+ * @param filters tag filters to normalize
+ * @returns normalized filters
+ * @throws when a key is duplicated
+ */
+export declare const normalizeTagFilters: (filters: readonly PipelineTagFilter[]) => PipelineTagFilter[];
+/**
+ * Converts CodePipeline tag entries into a key/value map.
+ *
+ * @param tags tags returned by ListTagsForResource
+ * @returns map of tag key to tag value
+ */
+export declare const toPipelineTagMap: (tags: readonly {
+    readonly key?: string;
+    readonly value?: string;
+}[] | undefined) => {
+    readonly [key: string]: string;
+};
+/**
+ * Returns whether pipeline tags satisfy every filter.
+ * Keys are AND; values within a filter are OR.
+ *
+ * @param pipelineTags tags currently on the pipeline
+ * @param filters required tag filters
+ * @returns true when the pipeline matches all filters
+ */
+export declare const matchesTargetPipelineTags: (pipelineTags: Readonly<{
+    [key: string]: string;
+}>, filters: readonly PipelineTagFilter[]) => boolean;
+/**
+ * Resolves a CodePipeline ARN for ListTagsForResource.
+ *
+ * @param resources EventBridge `resources` array
+ * @param region event region
+ * @param account event account
+ * @param pipelineName pipeline name from the event detail
+ * @returns ARN when it can be resolved
+ */
+export declare const resolvePipelineArn: (resources: readonly string[] | undefined, region: string | undefined, account: string | undefined, pipelineName: string) => string | undefined;
+/**
+ * Returns whether `value` is a non-empty list of non-empty strings.
+ *
+ * @param value unknown JSON value
+ * @returns true when the value is a string list
+ */
+export declare const isNonEmptyStringList: (value: unknown) => value is string[];
+/**
+ * Parses optional `TARGET_PIPELINE_ARNS` JSON into an ARN allowlist.
+ *
+ * @param raw JSON string from the environment, or undefined when unset
+ * @returns normalized ARNs, or undefined when the allowlist is not configured
+ * @throws when the JSON is invalid or not a string list
+ */
+export declare const parseAllowedPipelineArns: (raw: string | undefined) => string[] | undefined;
+/**
+ * Returns whether a pipeline ARN is allowed when an allowlist is configured.
+ *
+ * @param pipelineArn resolved pipeline ARN
+ * @param allowedArns optional allowlist
+ * @returns true when no allowlist is set, or the ARN is listed
+ */
+export declare const isAllowedPipelineArn: (pipelineArn: string, allowedArns: readonly string[] | undefined) => boolean;

package/lib/funcs/target-pipeline-predicates.js

@@ -0,0 +1,212 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAllowedPipelineArn = exports.parseAllowedPipelineArns = exports.isNonEmptyStringList = exports.resolvePipelineArn = exports.matchesTargetPipelineTags = exports.toPipelineTagMap = exports.normalizeTagFilters = exports.parseTargetPipelineTags = exports.isPipelineTagFilter = exports.isPipelineTagFilterList = void 0;
+const isNonEmptyString = (value) => typeof value === 'string' && value.trim().length > 0;
+/**
+ * Returns whether `value` is a non-empty list of `{ key, values }` tag filters.
+ *
+ * @param value unknown JSON value
+ * @returns true when the value can be used as tag filters
+ */
+const isPipelineTagFilterList = (value) => {
+    if (!Array.isArray(value) || value.length === 0) {
+        return false;
+    }
+    for (const item of value) {
+        if (!(0, exports.isPipelineTagFilter)(item)) {
+            return false;
+        }
+    }
+    return true;
+};
+exports.isPipelineTagFilterList = isPipelineTagFilterList;
+/**
+ * Returns whether `value` is a single tag filter with a non-empty key and values.
+ *
+ * @param value unknown JSON value
+ * @returns true when the value is a tag filter
+ */
+const isPipelineTagFilter = (value) => {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    if (!('key' in value) || !('values' in value)) {
+        return false;
+    }
+    if (!isNonEmptyString(value.key)) {
+        return false;
+    }
+    if (!Array.isArray(value.values) || value.values.length === 0) {
+        return false;
+    }
+    for (const tagValue of value.values) {
+        if (!isNonEmptyString(tagValue)) {
+            return false;
+        }
+    }
+    return true;
+};
+exports.isPipelineTagFilter = isPipelineTagFilter;
+/**
+ * Parses `TARGET_PIPELINE_TAGS` JSON into tag filters.
+ *
+ * @param raw JSON string from the environment
+ * @returns normalized tag filters
+ * @throws when the JSON is invalid or not a tag-filter list
+ */
+const parseTargetPipelineTags = (raw) => {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new Error('TARGET_PIPELINE_TAGS must be valid JSON');
+    }
+    if (!(0, exports.isPipelineTagFilterList)(parsed)) {
+        throw new Error('TARGET_PIPELINE_TAGS must be a non-empty array of { key, values }');
+    }
+    return (0, exports.normalizeTagFilters)(parsed);
+};
+exports.parseTargetPipelineTags = parseTargetPipelineTags;
+/**
+ * Trims keys/values and rejects duplicate keys.
+ *
+ * @param filters tag filters to normalize
+ * @returns normalized filters
+ * @throws when a key is duplicated
+ */
+const normalizeTagFilters = (filters) => {
+    const seenKeys = new Set();
+    const normalized = [];
+    for (const filter of filters) {
+        const key = filter.key.trim();
+        if (seenKeys.has(key)) {
+            throw new Error(`Tag filter list contains duplicate key: ${key}`);
+        }
+        seenKeys.add(key);
+        normalized.push({
+            key,
+            values: filter.values.map((value) => value.trim()),
+        });
+    }
+    return normalized;
+};
+exports.normalizeTagFilters = normalizeTagFilters;
+/**
+ * Converts CodePipeline tag entries into a key/value map.
+ *
+ * @param tags tags returned by ListTagsForResource
+ * @returns map of tag key to tag value
+ */
+const toPipelineTagMap = (tags) => {
+    const mapped = {};
+    if (!tags) {
+        return mapped;
+    }
+    for (const tag of tags) {
+        if (!tag.key || tag.value === undefined) {
+            continue;
+        }
+        mapped[tag.key] = tag.value;
+    }
+    return mapped;
+};
+exports.toPipelineTagMap = toPipelineTagMap;
+/**
+ * Returns whether pipeline tags satisfy every filter.
+ * Keys are AND; values within a filter are OR.
+ *
+ * @param pipelineTags tags currently on the pipeline
+ * @param filters required tag filters
+ * @returns true when the pipeline matches all filters
+ */
+const matchesTargetPipelineTags = (pipelineTags, filters) => {
+    for (const filter of filters) {
+        const actual = pipelineTags[filter.key];
+        if (actual === undefined) {
+            return false;
+        }
+        if (!filter.values.includes(actual)) {
+            return false;
+        }
+    }
+    return true;
+};
+exports.matchesTargetPipelineTags = matchesTargetPipelineTags;
+/**
+ * Resolves a CodePipeline ARN for ListTagsForResource.
+ *
+ * @param resources EventBridge `resources` array
+ * @param region event region
+ * @param account event account
+ * @param pipelineName pipeline name from the event detail
+ * @returns ARN when it can be resolved
+ */
+const resolvePipelineArn = (resources, region, account, pipelineName) => {
+    const fromResources = resources?.[0];
+    if (fromResources) {
+        return fromResources;
+    }
+    if (!region || !account) {
+        return undefined;
+    }
+    return `arn:aws:codepipeline:${region}:${account}:${pipelineName}`;
+};
+exports.resolvePipelineArn = resolvePipelineArn;
+/**
+ * Returns whether `value` is a non-empty list of non-empty strings.
+ *
+ * @param value unknown JSON value
+ * @returns true when the value is a string list
+ */
+const isNonEmptyStringList = (value) => {
+    if (!Array.isArray(value) || value.length === 0) {
+        return false;
+    }
+    for (const item of value) {
+        if (!isNonEmptyString(item)) {
+            return false;
+        }
+    }
+    return true;
+};
+exports.isNonEmptyStringList = isNonEmptyStringList;
+/**
+ * Parses optional `TARGET_PIPELINE_ARNS` JSON into an ARN allowlist.
+ *
+ * @param raw JSON string from the environment, or undefined when unset
+ * @returns normalized ARNs, or undefined when the allowlist is not configured
+ * @throws when the JSON is invalid or not a string list
+ */
+const parseAllowedPipelineArns = (raw) => {
+    if (raw === undefined || raw.trim() === '') {
+        return undefined;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new Error('TARGET_PIPELINE_ARNS must be valid JSON');
+    }
+    if (!(0, exports.isNonEmptyStringList)(parsed)) {
+        throw new Error('TARGET_PIPELINE_ARNS must be a non-empty array of strings');
+    }
+    return parsed.map((arn) => arn.trim());
+};
+exports.parseAllowedPipelineArns = parseAllowedPipelineArns;
+/**
+ * Returns whether a pipeline ARN is allowed when an allowlist is configured.
+ *
+ * @param pipelineArn resolved pipeline ARN
+ * @param allowedArns optional allowlist
+ * @returns true when no allowlist is set, or the ARN is listed
+ */
+const isAllowedPipelineArn = (pipelineArn, allowedArns) => {
+    if (!allowedArns) {
+        return true;
+    }
+    return allowedArns.includes(pipelineArn);
+};
+exports.isAllowedPipelineArn = isAllowedPipelineArn;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"target-pipeline-predicates.js","sourceRoot":"","sources":["../../src/funcs/target-pipeline-predicates.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Tag filter used to decide whether a CodePipeline should be notified.\n */\nexport interface PipelineTagFilter {\n  /**\n   * Tag key that must be present on the pipeline.\n   */\n  readonly key: string;\n\n  /**\n   * Accepted values for {@link key}. Matching is OR within this list.\n   */\n  readonly values: readonly string[];\n}\n\nconst isNonEmptyString = (value: unknown): value is string =>\n  typeof value === 'string' && value.trim().length > 0;\n\n/**\n * Returns whether `value` is a non-empty list of `{ key, values }` tag filters.\n *\n * @param value unknown JSON value\n * @returns true when the value can be used as tag filters\n */\nexport const isPipelineTagFilterList = (value: unknown): value is PipelineTagFilter[] => {\n  if (!Array.isArray(value) || value.length === 0) {\n    return false;\n  }\n\n  for (const item of value) {\n    if (!isPipelineTagFilter(item)) {\n      return false;\n    }\n  }\n\n  return true;\n};\n\n/**\n * Returns whether `value` is a single tag filter with a non-empty key and values.\n *\n * @param value unknown JSON value\n * @returns true when the value is a tag filter\n */\nexport const isPipelineTagFilter = (value: unknown): value is PipelineTagFilter => {\n  if (typeof value !== 'object' || value === null) {\n    return false;\n  }\n  if (!('key' in value) || !('values' in value)) {\n    return false;\n  }\n  if (!isNonEmptyString(value.key)) {\n    return false;\n  }\n  if (!Array.isArray(value.values) || value.values.length === 0) {\n    return false;\n  }\n\n  for (const tagValue of value.values) {\n    if (!isNonEmptyString(tagValue)) {\n      return false;\n    }\n  }\n\n  return true;\n};\n\n/**\n * Parses `TARGET_PIPELINE_TAGS` JSON into tag filters.\n *\n * @param raw JSON string from the environment\n * @returns normalized tag filters\n * @throws when the JSON is invalid or not a tag-filter list\n */\nexport const parseTargetPipelineTags = (raw: string): PipelineTagFilter[] => {\n  let parsed: unknown;\n  try {\n    parsed = JSON.parse(raw);\n  } catch {\n    throw new Error('TARGET_PIPELINE_TAGS must be valid JSON');\n  }\n\n  if (!isPipelineTagFilterList(parsed)) {\n    throw new Error('TARGET_PIPELINE_TAGS must be a non-empty array of { key, values }');\n  }\n\n  return normalizeTagFilters(parsed);\n};\n\n/**\n * Trims keys/values and rejects duplicate keys.\n *\n * @param filters tag filters to normalize\n * @returns normalized filters\n * @throws when a key is duplicated\n */\nexport const normalizeTagFilters = (filters: readonly PipelineTagFilter[]): PipelineTagFilter[] => {\n  const seenKeys = new Set<string>();\n  const normalized: PipelineTagFilter[] = [];\n\n  for (const filter of filters) {\n    const key = filter.key.trim();\n    if (seenKeys.has(key)) {\n      throw new Error(`Tag filter list contains duplicate key: ${key}`);\n    }\n    seenKeys.add(key);\n\n    normalized.push({\n      key,\n      values: filter.values.map((value) => value.trim()),\n    });\n  }\n\n  return normalized;\n};\n\n/**\n * Converts CodePipeline tag entries into a key/value map.\n *\n * @param tags tags returned by ListTagsForResource\n * @returns map of tag key to tag value\n */\nexport const toPipelineTagMap = (\n  tags: readonly { readonly key?: string; readonly value?: string }[] | undefined,\n): { readonly [key: string]: string } => {\n  const mapped: { [key: string]: string } = {};\n  if (!tags) {\n    return mapped;\n  }\n\n  for (const tag of tags) {\n    if (!tag.key || tag.value === undefined) {\n      continue;\n    }\n    mapped[tag.key] = tag.value;\n  }\n\n  return mapped;\n};\n\n/**\n * Returns whether pipeline tags satisfy every filter.\n * Keys are AND; values within a filter are OR.\n *\n * @param pipelineTags tags currently on the pipeline\n * @param filters required tag filters\n * @returns true when the pipeline matches all filters\n */\nexport const matchesTargetPipelineTags = (\n  pipelineTags: Readonly<{ [key: string]: string }>,\n  filters: readonly PipelineTagFilter[],\n): boolean => {\n  for (const filter of filters) {\n    const actual = pipelineTags[filter.key];\n    if (actual === undefined) {\n      return false;\n    }\n    if (!filter.values.includes(actual)) {\n      return false;\n    }\n  }\n\n  return true;\n};\n\n/**\n * Resolves a CodePipeline ARN for ListTagsForResource.\n *\n * @param resources EventBridge `resources` array\n * @param region event region\n * @param account event account\n * @param pipelineName pipeline name from the event detail\n * @returns ARN when it can be resolved\n */\nexport const resolvePipelineArn = (\n  resources: readonly string[] | undefined,\n  region: string | undefined,\n  account: string | undefined,\n  pipelineName: string,\n): string | undefined => {\n  const fromResources = resources?.[0];\n  if (fromResources) {\n    return fromResources;\n  }\n  if (!region || !account) {\n    return undefined;\n  }\n\n  return `arn:aws:codepipeline:${region}:${account}:${pipelineName}`;\n};\n\n/**\n * Returns whether `value` is a non-empty list of non-empty strings.\n *\n * @param value unknown JSON value\n * @returns true when the value is a string list\n */\nexport const isNonEmptyStringList = (value: unknown): value is string[] => {\n  if (!Array.isArray(value) || value.length === 0) {\n    return false;\n  }\n\n  for (const item of value) {\n    if (!isNonEmptyString(item)) {\n      return false;\n    }\n  }\n\n  return true;\n};\n\n/**\n * Parses optional `TARGET_PIPELINE_ARNS` JSON into an ARN allowlist.\n *\n * @param raw JSON string from the environment, or undefined when unset\n * @returns normalized ARNs, or undefined when the allowlist is not configured\n * @throws when the JSON is invalid or not a string list\n */\nexport const parseAllowedPipelineArns = (raw: string | undefined): string[] | undefined => {\n  if (raw === undefined || raw.trim() === '') {\n    return undefined;\n  }\n\n  let parsed: unknown;\n  try {\n    parsed = JSON.parse(raw);\n  } catch {\n    throw new Error('TARGET_PIPELINE_ARNS must be valid JSON');\n  }\n\n  if (!isNonEmptyStringList(parsed)) {\n    throw new Error('TARGET_PIPELINE_ARNS must be a non-empty array of strings');\n  }\n\n  return parsed.map((arn) => arn.trim());\n};\n\n/**\n * Returns whether a pipeline ARN is allowed when an allowlist is configured.\n *\n * @param pipelineArn resolved pipeline ARN\n * @param allowedArns optional allowlist\n * @returns true when no allowlist is set, or the ARN is listed\n */\nexport const isAllowedPipelineArn = (\n  pipelineArn: string,\n  allowedArns: readonly string[] | undefined,\n): boolean => {\n  if (!allowedArns) {\n    return true;\n  }\n\n  return allowedArns.includes(pipelineArn);\n};\n\n"]}

package/lib/index.d.ts

@@ -1 +1 @@
-export { CodePipelineEventNotifier, CodePipelineEventNotifierProps, } from './constructs/codepipeline-event-notifier';
+export { CodePipelineEventNotifier, CodePipelineEventNotifierProps, TargetPipeline, TargetPipelineTag, } from './constructs/codepipeline-event-notifier';

package/lib/index.js

@@ -3,4 +3,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CodePipelineEventNotifier = void 0;
 var codepipeline_event_notifier_1 = require("./constructs/codepipeline-event-notifier");
 Object.defineProperty(exports, "CodePipelineEventNotifier", { enumerable: true, get: function () { return codepipeline_event_notifier_1.CodePipelineEventNotifier; } });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsd0ZBR2tEO0FBRmhELHdJQUFBLHlCQUF5QixPQUFBIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHtcbiAgQ29kZVBpcGVsaW5lRXZlbnROb3RpZmllcixcbiAgQ29kZVBpcGVsaW5lRXZlbnROb3RpZmllclByb3BzLFxufSBmcm9tICcuL2NvbnN0cnVjdHMvY29kZXBpcGVsaW5lLWV2ZW50LW5vdGlmaWVyJztcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsd0ZBS2tEO0FBSmhELHdJQUFBLHlCQUF5QixPQUFBIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHtcbiAgQ29kZVBpcGVsaW5lRXZlbnROb3RpZmllcixcbiAgQ29kZVBpcGVsaW5lRXZlbnROb3RpZmllclByb3BzLFxuICBUYXJnZXRQaXBlbGluZSxcbiAgVGFyZ2V0UGlwZWxpbmVUYWcsXG59IGZyb20gJy4vY29uc3RydWN0cy9jb2RlcGlwZWxpbmUtZXZlbnQtbm90aWZpZXInO1xuIl19

package/lib/stacks/codepipeline-event-notify-stack.js

@@ -13,8 +13,17 @@ class CodePipelineEventNotifyStack extends aws_cdk_lib_1.Stack {
      */
     constructor(scope, id) {
         super(scope, id);
-        new codepipeline_event_notifier_1.CodePipelineEventNotifier(this, 'CodePipelineEventNotifier');
+        new codepipeline_event_notifier_1.CodePipelineEventNotifier(this, 'CodePipelineEventNotifier', {
+            targetPipeline: {
+                tags: [
+                    {
+                        key: 'Notify',
+                        values: ['true'],
+                    },
+                ],
+            },
+        });
     }
 }
 exports.CodePipelineEventNotifyStack = CodePipelineEventNotifyStack;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29kZXBpcGVsaW5lLWV2ZW50LW5vdGlmeS1zdGFjay5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zdGFja3MvY29kZXBpcGVsaW5lLWV2ZW50LW5vdGlmeS1zdGFjay50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSw2Q0FBb0M7QUFFcEMsMkZBQXNGO0FBRXRGOztHQUVHO0FBQ0gsTUFBYSw0QkFBNkIsU0FBUSxtQkFBSztJQUNyRDs7O09BR0c7SUFDSCxZQUFZLEtBQWdCLEVBQUUsRUFBVTtRQUN0QyxLQUFLLENBQUMsS0FBSyxFQUFFLEVBQUUsQ0FBQyxDQUFDO1FBRWpCLElBQUksdURBQXlCLENBQUMsSUFBSSxFQUFFLDJCQUEyQixDQUFDLENBQUM7SUFDbkUsQ0FBQztDQUNGO0FBVkQsb0VBVUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBTdGFjayB9IGZyb20gJ2F3cy1jZGstbGliJztcbmltcG9ydCB7IENvbnN0cnVjdCB9IGZyb20gJ2NvbnN0cnVjdHMnO1xuaW1wb3J0IHsgQ29kZVBpcGVsaW5lRXZlbnROb3RpZmllciB9IGZyb20gJy4uL2NvbnN0cnVjdHMvY29kZXBpcGVsaW5lLWV2ZW50LW5vdGlmaWVyJztcblxuLyoqXG4gKiBFeGFtcGxlIHN0YWNrIHdpcmluZyB1cCB7QGxpbmsgQ29kZVBpcGVsaW5lRXZlbnROb3RpZmllcn0uXG4gKi9cbmV4cG9ydCBjbGFzcyBDb2RlUGlwZWxpbmVFdmVudE5vdGlmeVN0YWNrIGV4dGVuZHMgU3RhY2sge1xuICAvKipcbiAgICogQHBhcmFtIHNjb3BlIHRoZSBhcHAgc2NvcGVcbiAgICogQHBhcmFtIGlkIHRoZSBzdGFjayBpZFxuICAgKi9cbiAgY29uc3RydWN0b3Ioc2NvcGU6IENvbnN0cnVjdCwgaWQ6IHN0cmluZykge1xuICAgIHN1cGVyKHNjb3BlLCBpZCk7XG5cbiAgICBuZXcgQ29kZVBpcGVsaW5lRXZlbnROb3RpZmllcih0aGlzLCAnQ29kZVBpcGVsaW5lRXZlbnROb3RpZmllcicpO1xuICB9XG59Il19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29kZXBpcGVsaW5lLWV2ZW50LW5vdGlmeS1zdGFjay5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zdGFja3MvY29kZXBpcGVsaW5lLWV2ZW50LW5vdGlmeS1zdGFjay50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSw2Q0FBb0M7QUFFcEMsMkZBQXNGO0FBRXRGOztHQUVHO0FBQ0gsTUFBYSw0QkFBNkIsU0FBUSxtQkFBSztJQUNyRDs7O09BR0c7SUFDSCxZQUFZLEtBQWdCLEVBQUUsRUFBVTtRQUN0QyxLQUFLLENBQUMsS0FBSyxFQUFFLEVBQUUsQ0FBQyxDQUFDO1FBRWpCLElBQUksdURBQXlCLENBQUMsSUFBSSxFQUFFLDJCQUEyQixFQUFFO1lBQy9ELGNBQWMsRUFBRTtnQkFDZCxJQUFJLEVBQUU7b0JBQ0o7d0JBQ0UsR0FBRyxFQUFFLFFBQVE7d0JBQ2IsTUFBTSxFQUFFLENBQUMsTUFBTSxDQUFDO3FCQUNqQjtpQkFDRjthQUNGO1NBQ0YsQ0FBQyxDQUFDO0lBQ0wsQ0FBQztDQUNGO0FBbkJELG9FQW1CQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFN0YWNrIH0gZnJvbSAnYXdzLWNkay1saWInO1xuaW1wb3J0IHsgQ29uc3RydWN0IH0gZnJvbSAnY29uc3RydWN0cyc7XG5pbXBvcnQgeyBDb2RlUGlwZWxpbmVFdmVudE5vdGlmaWVyIH0gZnJvbSAnLi4vY29uc3RydWN0cy9jb2RlcGlwZWxpbmUtZXZlbnQtbm90aWZpZXInO1xuXG4vKipcbiAqIEV4YW1wbGUgc3RhY2sgd2lyaW5nIHVwIHtAbGluayBDb2RlUGlwZWxpbmVFdmVudE5vdGlmaWVyfS5cbiAqL1xuZXhwb3J0IGNsYXNzIENvZGVQaXBlbGluZUV2ZW50Tm90aWZ5U3RhY2sgZXh0ZW5kcyBTdGFjayB7XG4gIC8qKlxuICAgKiBAcGFyYW0gc2NvcGUgdGhlIGFwcCBzY29wZVxuICAgKiBAcGFyYW0gaWQgdGhlIHN0YWNrIGlkXG4gICAqL1xuICBjb25zdHJ1Y3RvcihzY29wZTogQ29uc3RydWN0LCBpZDogc3RyaW5nKSB7XG4gICAgc3VwZXIoc2NvcGUsIGlkKTtcblxuICAgIG5ldyBDb2RlUGlwZWxpbmVFdmVudE5vdGlmaWVyKHRoaXMsICdDb2RlUGlwZWxpbmVFdmVudE5vdGlmaWVyJywge1xuICAgICAgdGFyZ2V0UGlwZWxpbmU6IHtcbiAgICAgICAgdGFnczogW1xuICAgICAgICAgIHtcbiAgICAgICAgICAgIGtleTogJ05vdGlmeScsXG4gICAgICAgICAgICB2YWx1ZXM6IFsndHJ1ZSddLFxuICAgICAgICAgIH0sXG4gICAgICAgIF0sXG4gICAgICB9LFxuICAgIH0pO1xuICB9XG59Il19

package/package.json

@@ -41,6 +41,7 @@
   "devDependencies": {
     "@aws-sdk/client-codepipeline": "^3.1080.0",
     "@aws-sdk/client-sns": "^3.1080.0",
+    "@gammarers/projen-projects": "^0.2.4",
     "@stylistic/eslint-plugin": "^2",
     "@types/aws-lambda": "^8.10.162",
     "@types/jest": "^30.0.0",
@@ -48,20 +49,20 @@
     "@typescript-eslint/eslint-plugin": "^8",
     "@typescript-eslint/parser": "^8",
     "aws-cdk-lib": "2.232.0",
-    "commit-and-tag-version": "^12",
+    "commit-and-tag-version": "^13",
     "constructs": "10.5.1",
     "esbuild": "^0.28.2",
     "eslint": "^9",
     "eslint-import-resolver-typescript": "^4.4.5",
     "eslint-plugin-import": "^2.32.0",
-    "jest": "^30.5.1",
+    "jest": "^30.5.2",
     "jest-junit": "^17",
     "jsii": "6.0.x",
     "jsii-diff": "^1.140.0",
     "jsii-docgen": "^10.5.0",
     "jsii-pacmak": "^1.140.0",
     "jsii-rosetta": "6.0.x",
-    "projen": "^0.103.23",
+    "projen": "^0.103.25",
     "strict-env-resolver": "^0.5.1",
     "ts-jest": "^29.4.12",
     "ts-node": "^10.9.2",
@@ -89,7 +90,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.2.8",
+  "version": "0.3.1",
   "jest": {
     "coverageProvider": "v8",
     "testMatch": [