codepipeline-event-notifier 0.1.1

package/API.md

@@ -0,0 +1,39 @@
+# API Reference <a name="API Reference" id="api-reference"></a>
+
+
+
+## Classes <a name="Classes" id="Classes"></a>
+
+### Hello <a name="Hello" id="codepipeline-event-notifier.Hello"></a>
+
+#### Initializers <a name="Initializers" id="codepipeline-event-notifier.Hello.Initializer"></a>
+
+```typescript
+import { Hello } from 'codepipeline-event-notifier'
+
+new Hello()
+```
+
+| **Name** | **Type** | **Description** |
+| --- | --- | --- |
+
+---
+
+#### Methods <a name="Methods" id="Methods"></a>
+
+| **Name** | **Description** |
+| --- | --- |
+| <code><a href="#codepipeline-event-notifier.Hello.sayHello">sayHello</a></code> | *No description.* |
+
+---
+
+##### `sayHello` <a name="sayHello" id="codepipeline-event-notifier.Hello.sayHello"></a>
+
+```typescript
+public sayHello(): string
+```
+
+
+
+
+

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,62 @@
+# CodePipeline Event Notifier
+
+[![npm version](https://img.shields.io/npm/v/codepipeline-event-notifier.svg)](https://www.npmjs.com/package/codepipeline-event-notifier)
+[![license](https://img.shields.io/npm/l/codepipeline-event-notifier.svg)](LICENSE)
+
+CDK construct that listens to **AWS CodePipeline execution STARTED** events via EventBridge, invokes a Lambda notifier, and publishes execution state changes to an SNS topic.
+
+## Features
+
+- **EventBridge integration**: triggers on `CodePipeline Pipeline Execution State Change` with `state=STARTED`
+- **SNS notifications**: publishes execution status transitions (observed while polling) as JSON messages
+- **Execution polling**: polls `GetPipelineExecution` until a terminal state or timeout
+- **No subscriptions by default**: the SNS Topic is created, but subscriptions (email/HTTP/etc.) are intentionally not configured
+
+## Installation
+
+### npm
+
+```bash
+npm install codepipeline-event-notifier
+```
+
+### yarn
+
+```bash
+yarn add codepipeline-event-notifier
+```
+
+## Usage
+
+Instantiate `CodePipelineEventNotifier` in your CDK stack:
+
+```ts
+import { Stack } from 'aws-cdk-lib';
+import { Construct } from 'constructs';
+import { CodePipelineEventNotifier } from 'codepipeline-event-notifier';
+
+export class MyStack extends Stack {
+  constructor(scope: Construct, id: string) {
+    super(scope, id);
+
+    new CodePipelineEventNotifier(this, 'CodePipelineEventNotifier');
+  }
+}
+```
+
+## Options
+
+The notifier Lambda supports the following environment variables:
+
+- `SNS_TOPIC_ARN` (**required**): SNS topic ARN to publish notifications to (provided by the construct)
+- `POLL_INTERVAL_SECONDS` (default: `10`): poll interval in seconds
+- `MAX_POLL_MINUTES` (default: `14`): maximum polling duration in minutes (Lambda should be configured with a matching timeout)
+
+## Requirements
+
+- Node.js `>= 20`
+- AWS CDK `v2` (`aws-cdk-lib`)
+
+## License
+
+This project is licensed under the Apache-2.0 License.

package/assets/funcs/notifier.lambda/index.js

@@ -0,0 +1,296 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// node_modules/strict-env-resolver/lib/index.js
+var require_lib = __commonJS({
+  "node_modules/strict-env-resolver/lib/index.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.StrictEnvResolver = exports2.StrictEnvType = exports2.StrictEnvValidationError = exports2.StrictEnvError = void 0;
+    var TRUE_BOOLEAN_PATTERN = /^(1|true|yes|on)$/i;
+    var parseNumber = (raw) => {
+      const n = Number(raw);
+      if (!Number.isFinite(n)) {
+        return void 0;
+      }
+      return n;
+    };
+    var parseBooleanEnvValue = (normalizedRaw) => TRUE_BOOLEAN_PATTERN.test(normalizedRaw);
+    var StrictEnvError = class extends Error {
+      /**
+       * @param message - Error message.
+       */
+      constructor(message) {
+        super(message);
+        this.name = "StrictEnvError";
+      }
+    };
+    exports2.StrictEnvError = StrictEnvError;
+    var StrictEnvValidationError = class _StrictEnvValidationError extends StrictEnvError {
+      /**
+       * Formats validation errors into a human-readable error message.
+       *
+       * @template K - Environment variable key type.
+       * @param errors - Validation error entries to format.
+       * @returns Multi-line summary listing each key and message.
+       */
+      static format(errors) {
+        const lines = errors.map((e) => `- ${e.key}: ${e.message}${e.raw == null ? "" : ` (raw="${e.raw}")`}`);
+        return `Invalid environment variables (${errors.length}):
+${lines.join("\n")}`;
+      }
+      /**
+       * Creates a new validation error from one or more `StrictEnvValidationEntry` entries.
+       *
+       * @param errors - One or more structured validation errors.
+       */
+      constructor(errors) {
+        const msg = _StrictEnvValidationError.format(errors);
+        super(msg);
+        this.name = "StrictEnvValidationError";
+        this.errors = errors;
+        this.keys = errors.map((e) => e.key);
+      }
+    };
+    exports2.StrictEnvValidationError = StrictEnvValidationError;
+    exports2.StrictEnvType = {
+      /** Spec for a string value (returned as-is unless `trim: true` is set in options). */
+      String: { type: "string" },
+      /**
+       * Spec for a finite numeric value (`Number()` parsing; rejects `NaN` and `Infinity`).
+       */
+      Number: { type: "number" },
+      /** Spec for a boolean value (`1`/`true`/`yes`/`on` → `true`; other non-empty values → `false`). */
+      Boolean: { type: "boolean" },
+      /**
+       * Returns a spec that restricts the value to one of the given choices.
+       *
+       * @param choices - Allowed string literals.
+       * @returns Enum spec for use with `resolve` or `resolveAll`.
+       */
+      Enum: (choices) => ({ type: "enum", choices })
+    };
+    var defaultTrimForSpec = (spec) => spec.type !== "string";
+    var normalizeEnvRaw = (raw, trim) => {
+      if (raw == null) {
+        return void 0;
+      }
+      if (!trim) {
+        return raw;
+      }
+      return raw.trim();
+    };
+    var resolveSchemaEntry = (entry) => ({
+      spec: Array.isArray(entry) ? entry[0] : entry,
+      options: Array.isArray(entry) ? entry[1] : void 0
+    });
+    var parseEnvValue = (key, spec, raw, defaultValue, options) => {
+      const trim = options?.trim ?? defaultTrimForSpec(spec);
+      const normalizedRaw = normalizeEnvRaw(raw, trim);
+      const hasDefault = defaultValue !== void 0;
+      if (normalizedRaw == null || normalizedRaw === "") {
+        if (hasDefault) {
+          return { ok: true, value: defaultValue };
+        }
+        return {
+          ok: false,
+          error: { key, message: `Missing required environment variable: ${key}`, raw, kind: "missing" }
+        };
+      }
+      switch (spec.type) {
+        case "number": {
+          const n = parseNumber(normalizedRaw);
+          if (n === void 0) {
+            return {
+              ok: false,
+              error: { key, message: `Env ${key}: expected number, got "${raw}"`, raw, kind: "invalid_number" }
+            };
+          }
+          return { ok: true, value: n };
+        }
+        case "boolean":
+          return { ok: true, value: parseBooleanEnvValue(normalizedRaw) };
+        case "enum":
+          if (!spec.choices.includes(normalizedRaw)) {
+            return {
+              ok: false,
+              error: {
+                key,
+                message: `Env ${key}: must be one of [${spec.choices.join(", ")}]`,
+                raw,
+                kind: "invalid_enum"
+              }
+            };
+          }
+          return { ok: true, value: normalizedRaw };
+        default:
+          return { ok: true, value: normalizedRaw };
+      }
+    };
+    var resolve = (key, spec = exports2.StrictEnvType.String, options) => {
+      const result = parseEnvValue(key, spec, process.env[key], options?.default, options);
+      if (!result.ok) {
+        throw new StrictEnvValidationError([result.error]);
+      }
+      return result.value;
+    };
+    var resolveAll = (schema) => {
+      const envs = {};
+      const errors = [];
+      for (const key of Object.keys(schema)) {
+        const { spec, options } = resolveSchemaEntry(schema[key]);
+        const result = parseEnvValue(key, spec, process.env[key], options?.default, options);
+        if (!result.ok) {
+          errors.push(result.error);
+          continue;
+        }
+        envs[key] = result.value;
+      }
+      if (errors.length > 0)
+        throw new StrictEnvValidationError(errors);
+      return envs;
+    };
+    exports2.StrictEnvResolver = {
+      /** Reads and parses a single environment variable. See {@link resolve}. */
+      resolve,
+      /** Reads and parses multiple environment variables in one pass. See {@link resolveAll}. */
+      resolveAll
+    };
+  }
+});
+
+// src/funcs/notifier.lambda.ts
+var notifier_lambda_exports = {};
+__export(notifier_lambda_exports, {
+  handler: () => handler
+});
+module.exports = __toCommonJS(notifier_lambda_exports);
+var import_client_codepipeline = require("@aws-sdk/client-codepipeline");
+var import_client_sns = require("@aws-sdk/client-sns");
+var import_strict_env_resolver = __toESM(require_lib());
+var sns = new import_client_sns.SNSClient({});
+var codepipeline = new import_client_codepipeline.CodePipelineClient({});
+var mustEnv = (name) => import_strict_env_resolver.StrictEnvResolver.resolve(name, import_strict_env_resolver.StrictEnvType.String, { trim: true });
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var publish = async (topicArn, payload) => {
+  await sns.send(new import_client_sns.PublishCommand({
+    TopicArn: topicArn,
+    Message: JSON.stringify(payload)
+  }));
+};
+var pollPipelineExecution = async (params) => {
+  const {
+    topicArn,
+    pipelineName,
+    executionId,
+    pollIntervalSeconds,
+    maxPollMinutes,
+    startEvent
+  } = params;
+  const deadline = Date.now() + maxPollMinutes * 6e4;
+  let lastStatus;
+  await publish(topicArn, {
+    type: "codepipeline.execution",
+    phase: "eventbridge",
+    pipelineName,
+    executionId,
+    observedState: startEvent.detail?.state ?? "STARTED",
+    observedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    event: startEvent
+  });
+  while (Date.now() < deadline) {
+    const res = await codepipeline.send(new import_client_codepipeline.GetPipelineExecutionCommand({
+      pipelineName,
+      pipelineExecutionId: executionId
+    }));
+    const statusRaw = res.pipelineExecution?.status ?? "UNKNOWN";
+    const status = String(statusRaw).toUpperCase();
+    if (status !== lastStatus) {
+      lastStatus = status;
+      await publish(topicArn, {
+        type: "codepipeline.execution",
+        phase: "poll",
+        pipelineName,
+        executionId,
+        observedState: status,
+        observedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+    if (status === "SUCCEEDED" || status === "FAILED" || status === "STOPPED" || status === "SUPERSEDED") {
+      return;
+    }
+    await sleep(pollIntervalSeconds * 1e3);
+  }
+  await publish(topicArn, {
+    type: "codepipeline.execution",
+    phase: "poll",
+    pipelineName,
+    executionId,
+    observedState: lastStatus ?? "UNKNOWN",
+    observedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    note: "Polling timed out before terminal state."
+  });
+};
+var handler = async (event) => {
+  const topicArn = mustEnv("SNS_TOPIC_ARN");
+  const pipelineName = event.detail?.pipeline;
+  const executionId = event.detail?.["execution-id"];
+  if (!pipelineName || !executionId) {
+    await publish(topicArn, {
+      type: "codepipeline.execution",
+      phase: "eventbridge",
+      observedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      note: "Missing pipelineName or executionId in event.detail",
+      event
+    });
+    return;
+  }
+  const pollIntervalSeconds = import_strict_env_resolver.StrictEnvResolver.resolve("POLL_INTERVAL_SECONDS", import_strict_env_resolver.StrictEnvType.Number, { default: 10 });
+  const maxPollMinutes = import_strict_env_resolver.StrictEnvResolver.resolve("MAX_POLL_MINUTES", import_strict_env_resolver.StrictEnvType.Number, { default: 14 });
+  await pollPipelineExecution({
+    topicArn,
+    pipelineName,
+    executionId,
+    pollIntervalSeconds: pollIntervalSeconds > 0 ? pollIntervalSeconds : 10,
+    maxPollMinutes: maxPollMinutes > 0 ? maxPollMinutes : 14,
+    startEvent: event
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  handler
+});
+//# sourceMappingURL=index.js.map

package/assets/funcs/notifier.lambda/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../node_modules/strict-env-resolver/src/index.ts", "../../../src/funcs/notifier.lambda.ts"],
+  "sourcesContent": ["/**\n * Spec for a string environment variable.\n * Returned as-is by default (`trim` defaults to `false`). Set `trim: true` in options to trim\n * whitespace and treat whitespace-only values as missing.\n * The default value is passed via the third argument of `resolve` or a `[spec, options]` tuple in `resolveAll`, not in the spec.\n */\nexport type StrictEnvTypeString = { type: 'string'; default?: string };\n\n/**\n * Spec for a numeric environment variable.\n * Values are parsed with `Number()`; `NaN`, `Infinity`, and `-Infinity` are rejected.\n * The default value is passed via the third argument of `resolve` or a `[spec, options]` tuple in `resolveAll`, not in the spec.\n */\nexport type StrictEnvTypeNumber = { type: 'number'; default?: number };\n\n/**\n * Pattern for boolean env values that parse as `true`.\n * Matches `1`, `true`, `yes`, and `on` (case-insensitive) on the full trimmed string.\n */\nconst TRUE_BOOLEAN_PATTERN = /^(1|true|yes|on)$/i;\n\n/**\n * Parses a string as a finite number for environment variables.\n *\n * @param raw - Trimmed environment variable value.\n * @returns Parsed number, or `undefined` when the value is not a finite number.\n */\nconst parseNumber = (raw: string): number | undefined => {\n  const n = Number(raw);\n  if (!Number.isFinite(n)) {\n    return undefined;\n  }\n  return n;\n};\n\n/**\n * Parses a trimmed string as a boolean environment variable value.\n *\n * @param normalizedRaw - Trimmed raw environment variable value.\n * @returns `true` for `1`/`true`/`yes`/`on` (case-insensitive); otherwise `false`.\n */\nconst parseBooleanEnvValue = (normalizedRaw: string): boolean => TRUE_BOOLEAN_PATTERN.test(normalizedRaw);\n\n/**\n * Spec for a boolean environment variable.\n * Parses `1`, `true`, `yes`, `on` (case-insensitive, after trim) as `true`; any other non-empty value as `false`.\n * Trims leading/trailing whitespace by default (see `StrictEnvOptions.trim`).\n * The default value is passed via the third argument of `resolve` or a `[spec, options]` tuple in `resolveAll`, not in the spec.\n */\nexport type StrictEnvTypeBoolean = { type: 'boolean'; default?: boolean };\n\n/**\n * Spec for an enum environment variable with a fixed set of choices.\n * The value must be one of `choices` (compared after trim); otherwise validation fails.\n * Trims leading/trailing whitespace by default (see `StrictEnvOptions.trim`).\n * The default value is passed via the third argument of `resolve` or a `[spec, options]` tuple in `resolveAll`, not in the spec.\n *\n * @template T - Literal string union of allowed values.\n */\nexport type StrictEnvTypeEnum<T extends string = string> = { type: 'enum'; choices: readonly T[]; default?: T };\n\n/** Union of all environment variable spec types. */\nexport type StrictEnvSpec =\n  | StrictEnvTypeString\n  | StrictEnvTypeNumber\n  | StrictEnvTypeBoolean\n  | StrictEnvTypeEnum;\n\n/**\n * Discriminated union of error kinds emitted during environment variable parsing.\n *\n * - `missing` — Variable unset, empty string, or whitespace-only (when trim is enabled) without a default.\n * - `invalid_number` — Value is not a finite number (see `StrictEnvTypeNumber`).\n * - `invalid_enum` — Value is not one of the allowed enum choices.\n */\nexport type StrictEnvErrorKind = 'missing' | 'invalid_number' | 'invalid_enum';\n\n/**\n * A structured validation error entry for a single environment variable.\n *\n * @template K - Environment variable key type.\n */\nexport type StrictEnvValidationEntry<K extends string = string> = {\n  /** Environment variable name. */\n  key: K;\n  /** Human-readable error message. */\n  message: string;\n  /** Raw value from `process.env`, if present. */\n  raw?: string;\n  /** Error category for programmatic handling. */\n  kind: StrictEnvErrorKind;\n};\n\n/**\n * Base error class for this package.\n *\n * @example\n * ```ts\n * try {\n *   StrictEnvResolver.resolve('PORT', StrictEnvType.Number);\n * } catch (e) {\n *   if (e instanceof StrictEnvError) {\n *     // Handle all strict-env-resolver errors\n *   }\n * }\n * ```\n */\nexport abstract class StrictEnvError extends Error {\n  /**\n   * @param message - Error message.\n   */\n  protected constructor(message: string) {\n    super(message);\n    this.name = 'StrictEnvError';\n  }\n}\n\n/**\n * Validation error that carries one or more environment variable issues.\n *\n * Thrown by `StrictEnvResolver.resolve()` (single-entry `errors`) and\n * `StrictEnvResolver.resolveAll()` (multi-entry `errors`).\n * Individual entries are produced by the internal `parseEnvValue` helper.\n *\n * @template K - Union of environment variable keys included in `errors`.\n */\nexport class StrictEnvValidationError<K extends string = string> extends StrictEnvError {\n  /**\n   * Formats validation errors into a human-readable error message.\n   *\n   * @template K - Environment variable key type.\n   * @param errors - Validation error entries to format.\n   * @returns Multi-line summary listing each key and message.\n   */\n  public static format<K extends string>(errors: readonly StrictEnvValidationEntry<K>[]): string {\n    const lines = errors.map((e) => `- ${e.key}: ${e.message}${e.raw == null ? '' : ` (raw=\"${e.raw}\")`}`);\n    return `Invalid environment variables (${errors.length}):\\n${lines.join('\\n')}`;\n  }\n\n  /**\n   * Structured list of validation errors.\n   */\n  public readonly errors: readonly StrictEnvValidationEntry<K>[];\n  /**\n   * Convenience list of keys included in `errors`.\n   */\n  public readonly keys: readonly K[];\n\n  /**\n   * Creates a new validation error from one or more `StrictEnvValidationEntry` entries.\n   *\n   * @param errors - One or more structured validation errors.\n   */\n  public constructor(errors: readonly StrictEnvValidationEntry<K>[]) {\n    const msg = StrictEnvValidationError.format(errors);\n    super(msg);\n    this.name = 'StrictEnvValidationError';\n    this.errors = errors;\n    this.keys = errors.map((e) => e.key);\n  }\n}\n\n/**\n * Predefined spec constants for use with `resolve` or as schema values in `resolveAll`.\n * Provide defaults via the third argument of `resolve` or a `[spec, { default }]` tuple in `resolveAll`.\n */\nexport const StrictEnvType = {\n  /** Spec for a string value (returned as-is unless `trim: true` is set in options). */\n  String: { type: 'string' } as const satisfies StrictEnvTypeString,\n  /**\n   * Spec for a finite numeric value (`Number()` parsing; rejects `NaN` and `Infinity`).\n   */\n  Number: { type: 'number' } as const satisfies StrictEnvTypeNumber,\n  /** Spec for a boolean value (`1`/`true`/`yes`/`on` → `true`; other non-empty values → `false`). */\n  Boolean: { type: 'boolean' } as const satisfies StrictEnvTypeBoolean,\n  /**\n   * Returns a spec that restricts the value to one of the given choices.\n   *\n   * @param choices - Allowed string literals.\n   * @returns Enum spec for use with `resolve` or `resolveAll`.\n   */\n  Enum: <T extends string>(choices: readonly T[]) => ({ type: 'enum', choices }) as StrictEnvTypeEnum<T>,\n} as const;\n\n/**\n * Infers the return type from the given spec.\n * @template S - A `StrictEnvSpec` variant.\n */\nexport type StrictEnvSpecToType<S> =\n  S extends StrictEnvTypeString ? string\n    : S extends StrictEnvTypeNumber ? number\n      : S extends StrictEnvTypeBoolean ? boolean\n        : S extends StrictEnvTypeEnum<infer T> ? T\n          : never;\n\n/**\n * Options for reading an environment variable with an optional default.\n * Used as the third argument to `resolve` or as the second element of a `[spec, options]` tuple in `resolveAll`.\n *\n * `trim` defaults to `true` for `number`, `boolean`, and `enum` specs (whitespace-only values are\n * treated as missing). For `string` specs it defaults to `false` (values are returned as-is).\n *\n * @template S - Environment variable spec type.\n */\nexport type StrictEnvOptions<S extends StrictEnvSpec> = {\n  default?: StrictEnvSpecToType<S>;\n  /** When `true`, trims leading/trailing whitespace before validation. */\n  trim?: boolean;\n};\n\n/**\n * Schema entry for a single env var.\n *\n * Either provide a spec directly, or a tuple of `[spec, options]` to attach a default.\n */\nexport type StrictEnvSchemaEntry<S extends StrictEnvSpec = StrictEnvSpec> = S | readonly [S, StrictEnvOptions<S>];\n\n/**\n * Schema object used by `resolveAll()`.\n *\n * Keys are env var names, values are specs (optionally with defaults).\n */\nexport type StrictEnvSchema = Record<string, StrictEnvSchemaEntry>;\n\n/**\n * Extracts the spec type from a schema entry or `[spec, options]` tuple.\n *\n * @template E - Schema entry type.\n */\ntype StrictEnvSchemaEntryToSpec<E> = E extends readonly [infer S, unknown] ? S : E;\n\n/**\n * Maps a schema object to the resulting parsed environment object type.\n *\n * @template TSchema - Schema object type passed to `resolveAll`.\n */\nexport type StrictEnvSchemaToType<TSchema extends StrictEnvSchema> = {\n  [K in keyof TSchema]: StrictEnvSpecToType<StrictEnvSchemaEntryToSpec<TSchema[K]> & StrictEnvSpec>;\n};\n\n/**\n * Discriminated result of parsing a single environment variable.\n *\n * On success, `value` holds the parsed result. On failure, `error` holds a structured\n * `StrictEnvValidationEntry` entry (never throws).\n *\n * @template K - Environment variable key type.\n * @template S - Environment variable spec type.\n */\ntype ParseEnvValueResult<K extends string, S extends StrictEnvSpec> =\n  | { ok: true; value: StrictEnvSpecToType<S> }\n  | { ok: false; error: StrictEnvValidationEntry<K> };\n\n/**\n * Default trim behavior per spec type.\n * Parsed types trim by default; strings preserve the raw value unless opted in.\n *\n * @param spec - Environment variable spec.\n * @returns Whether leading/trailing whitespace should be trimmed before validation.\n */\nconst defaultTrimForSpec = (spec: StrictEnvSpec): boolean => spec.type !== 'string';\n\n/**\n * Normalizes a raw environment variable value before validation.\n *\n * @param raw - Raw value from `process.env`, if present.\n * @param trim - Whether to trim leading/trailing whitespace.\n * @returns Normalized value, or `undefined` when unset.\n */\nconst normalizeEnvRaw = (raw: string | undefined, trim: boolean): string | undefined => {\n  if (raw == null) {\n    return undefined;\n  }\n  if (!trim) {\n    return raw;\n  }\n  return raw.trim();\n};\n\n/** Options accepted by `parseEnvValue` (subset of `StrictEnvOptions`). */\ntype ParseEnvValueOptions<S extends StrictEnvSpec> = Pick<StrictEnvOptions<S>, 'trim'>;\n\n/**\n * Resolves a schema entry into its spec and optional per-key options.\n *\n * @param entry - Schema entry or `[spec, options]` tuple.\n * @returns Parsed spec and options for `resolveAll`.\n */\nconst resolveSchemaEntry = (\n  entry: StrictEnvSchemaEntry,\n): { spec: StrictEnvSpec; options: StrictEnvOptions<StrictEnvSpec> | undefined } => ({\n  spec: (Array.isArray(entry) ? entry[0] : entry) as StrictEnvSpec,\n  options: (Array.isArray(entry) ? entry[1] : undefined) as StrictEnvOptions<StrictEnvSpec> | undefined,\n});\n\n/**\n * Parses a single environment variable according to the given spec.\n *\n * Central validation helper shared by `resolve` and `resolveAll`. Does not throw;\n * callers decide whether to throw immediately or collect errors.\n *\n * Missing or empty (`\"\"`) values use `defaultValue` when provided. When `trim` is enabled,\n * whitespace-only values are treated as empty. Number specs delegate to `parseNumber`.\n * Boolean specs treat `1`/`true`/`yes`/`on` (case-insensitive, after trim) as `true`.\n * Enum specs require an exact match in `choices` (after trim).\n *\n * @template K - Environment variable key type.\n * @template S - Environment variable spec type.\n * @param key - Environment variable name.\n * @param spec - Type spec for the value.\n * @param raw - Raw value from `process.env`, if present.\n * @param defaultValue - Fallback when `raw` is missing or empty.\n * @param options - Optional trim override (`trim` defaults per spec type).\n * @returns Parsed value or a structured validation error.\n */\nconst parseEnvValue = <K extends string, S extends StrictEnvSpec>(\n  key: K,\n  spec: S,\n  raw: string | undefined,\n  defaultValue: StrictEnvSpecToType<S> | undefined,\n  options?: ParseEnvValueOptions<S>,\n): ParseEnvValueResult<K, S> => {\n  const trim = options?.trim ?? defaultTrimForSpec(spec);\n  const normalizedRaw = normalizeEnvRaw(raw, trim);\n  const hasDefault = defaultValue !== undefined;\n\n  if (normalizedRaw == null || normalizedRaw === '') {\n    if (hasDefault) {\n      return { ok: true, value: defaultValue as StrictEnvSpecToType<S> };\n    }\n    return {\n      ok: false,\n      error: { key, message: `Missing required environment variable: ${key}`, raw, kind: 'missing' },\n    };\n  }\n\n  switch (spec.type) {\n    case 'number': {\n      const n = parseNumber(normalizedRaw);\n      if (n === undefined) {\n        return {\n          ok: false,\n          error: { key, message: `Env ${key}: expected number, got \"${raw}\"`, raw, kind: 'invalid_number' },\n        };\n      }\n      return { ok: true, value: n as StrictEnvSpecToType<S> };\n    }\n    case 'boolean':\n      return { ok: true, value: parseBooleanEnvValue(normalizedRaw) as StrictEnvSpecToType<S> };\n    case 'enum':\n      if (!spec.choices.includes(normalizedRaw)) {\n        return {\n          ok: false,\n          error: {\n            key,\n            message: `Env ${key}: must be one of [${spec.choices.join(', ')}]`,\n            raw,\n            kind: 'invalid_enum',\n          },\n        };\n      }\n      return { ok: true, value: normalizedRaw as StrictEnvSpecToType<S> };\n    default:\n      return { ok: true, value: normalizedRaw as StrictEnvSpecToType<S> };\n  }\n};\n\n/**\n * Reads and parses an environment variable according to the given spec.\n *\n * Delegates validation to `parseEnvValue`. Missing or empty (`\"\"`) values use\n * `options.default` when provided; otherwise a `StrictEnvValidationError` is thrown.\n * For `StrictEnvType.Number`, values are parsed as finite numbers (see `StrictEnvTypeNumber`).\n *\n * @template K - Environment variable key type.\n * @template S - Environment variable spec type.\n * @param key - Environment variable name (e.g. `\"PORT\"`, `\"NODE_ENV\"`).\n * @param spec - Type spec; defaults to `StrictEnvType.String` when omitted.\n * @param options - Optional `{ default, trim }`; see {@link StrictEnvOptions}.\n * @returns Parsed value with type inferred from `spec`.\n * @throws {StrictEnvValidationError} When the variable is missing, empty without a default, or invalid for the spec.\n */\nconst resolve = <K extends string, S extends StrictEnvSpec = StrictEnvTypeString>(\n  key: K,\n  spec: S = StrictEnvType.String as S,\n  options?: StrictEnvOptions<S>,\n): StrictEnvSpecToType<S> => {\n  const result = parseEnvValue(key, spec, process.env[key], options?.default, options);\n  if (!result.ok) {\n    throw new StrictEnvValidationError([result.error]);\n  }\n  return result.value;\n};\n\n/**\n * Reads and parses multiple environment variables according to the given schema.\n *\n * Always evaluates every key in `schema`. Each entry is validated via `parseEnvValue`;\n * all errors are collected and thrown once in a single `StrictEnvValidationError`.\n * Number specs use the same finite-number rules as `resolve`.\n *\n * @template TSchema - Schema object type.\n * @param schema - Map of environment variable names to specs, optionally with per-key defaults via `[spec, { default }]`.\n * @returns Parsed environment object with types inferred from the schema.\n * @throws {StrictEnvValidationError} When one or more variables are missing, empty without a default, or invalid.\n */\nconst resolveAll = <TSchema extends StrictEnvSchema>(schema: TSchema): StrictEnvSchemaToType<TSchema> => {\n  const envs: Partial<StrictEnvSchemaToType<TSchema>> = {};\n  const errors: StrictEnvValidationEntry<Extract<keyof TSchema, string>>[] = [];\n\n  for (const key of Object.keys(schema) as Array<Extract<keyof TSchema, string>>) {\n    const { spec, options } = resolveSchemaEntry(schema[key]);\n\n    const result = parseEnvValue(key, spec, process.env[key], options?.default, options);\n    if (!result.ok) {\n      errors.push(result.error);\n      continue;\n    }\n    envs[key] = result.value as StrictEnvSchemaToType<TSchema>[typeof key];\n  }\n\n  if (errors.length > 0) throw new StrictEnvValidationError(errors);\n  return envs as StrictEnvSchemaToType<TSchema>;\n};\n\n/**\n * Type-safe environment variable resolver for Node.js `process.env`.\n *\n * @example\n * ```ts\n * const port = StrictEnvResolver.resolve('PORT', StrictEnvType.Number);\n * const envs = StrictEnvResolver.resolveAll({\n *   PORT: StrictEnvType.Number,\n *   DEBUG: [StrictEnvType.Boolean, { default: false }],\n * });\n * ```\n */\nexport const StrictEnvResolver = {\n  /** Reads and parses a single environment variable. See {@link resolve}. */\n  resolve,\n  /** Reads and parses multiple environment variables in one pass. See {@link resolveAll}. */\n  resolveAll,\n} as const;\n", "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';\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 poll execution state.\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 * Polls a CodePipeline execution and publishes notifications whenever the execution status changes.\n */\nconst pollPipelineExecution = async (params: {\n  topicArn: string;\n  pipelineName: string;\n  executionId: string;\n  pollIntervalSeconds: number;\n  maxPollMinutes: number;\n  startEvent: CodePipelineExecutionStartedEvent;\n}): Promise<void> => {\n  const {\n    topicArn,\n    pipelineName,\n    executionId,\n    pollIntervalSeconds,\n    maxPollMinutes,\n    startEvent,\n  } = params;\n\n  const deadline = Date.now() + maxPollMinutes * 60_000;\n  let lastStatus: string | undefined;\n\n  // \u6700\u521D\u306B STARTED \u3092\u901A\u77E5\uFF08EventBridge\u7531\u6765\uFF09\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 statusRaw = res.pipelineExecution?.status ?? 'UNKNOWN';\n    const status = String(statusRaw).toUpperCase();\n    if (status !== lastStatus) {\n      lastStatus = status;\n      await publish(topicArn, {\n        type: 'codepipeline.execution',\n        phase: 'poll',\n        pipelineName,\n        executionId,\n        observedState: status,\n        observedAt: new Date().toISOString(),\n      });\n    }\n\n    if (status === 'SUCCEEDED' || status === 'FAILED' || status === 'STOPPED' || status === 'SUPERSEDED') {\n      return;\n    }\n\n    await sleep(pollIntervalSeconds * 1000);\n  }\n\n  await publish(topicArn, {\n    type: 'codepipeline.execution',\n    phase: 'poll',\n    pipelineName,\n    executionId,\n    observedState: lastStatus ?? 'UNKNOWN',\n    observedAt: new Date().toISOString(),\n    note: 'Polling timed out before terminal state.',\n  });\n};\n\n/**\n * Lambda handler triggered by EventBridge when a pipeline execution transitions to STARTED.\n * It polls 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 pipelineName = event.detail?.pipeline;\n  const executionId = event.detail?.['execution-id'];\n\n  if (!pipelineName || !executionId) {\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 pollIntervalSeconds = StrictEnvResolver.resolve('POLL_INTERVAL_SECONDS', StrictEnvType.Number, { default: 10 });\n  const maxPollMinutes = StrictEnvResolver.resolve('MAX_POLL_MINUTES', StrictEnvType.Number, { default: 14 });\n\n  await pollPipelineExecution({\n    topicArn,\n    pipelineName,\n    executionId,\n    pollIntervalSeconds: pollIntervalSeconds > 0 ? pollIntervalSeconds : 10,\n    maxPollMinutes: maxPollMinutes > 0 ? maxPollMinutes : 14,\n    startEvent: event,\n  });\n};\n"],
+  "mappings": "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",
+  "names": ["exports"]
+}