AWS Lambda durable functionsでBacklog課題の完了サマリー自動生成しSlackでの承認フローを構築してみた

❯ /generate-issue-summary '/Users/ryuhei202/Backlog/issues/2025/Githubアカウントについてのご相談.md'

# Backlog APIキー
aws ssm put-parameter \
  --name "/backlog-completion-notifier/BACKLOG_API_KEY" \
  --value "YOUR_BACKLOG_API_KEY" \
  --type String

# Slack Bot Token
aws ssm put-parameter \
  --name "/backlog-completion-notifier/SLACK_BOT_TOKEN" \
  --value "xoxb-xxxxx" \
  --type String

git clone https://github.com/your-username/backlog-completion-notifier.git
cd backlog-completion-notifier

# 依存関係のインストール
pnpm install

# セットアップスクリプトを実行
pnpm setup

🔧 Backlog Completion Notifier セットアップ

Backlog スペースID: YOUR_BACKLOG_SPACE_ID
Slack チャンネルID: YOUR_SLACK_CHANNEL_ID

✅ 設定を保存しました: infra/config.ts

import type { Config } from "./config-type";

export const config: Config = {
  backlogSpaceId: "your-space-id", // BacklogのスペースID
  slackChannelId: "C0123456789",   // 通知先のSlackチャンネルID
};

pnpm run deploy

Outputs:
BacklogCompletionNotifierStack.BacklogWebhookUrl = https://xxxxx.lambda-url.ap-northeast-1.on.aws/webhook/backlog
BacklogCompletionNotifierStack.SlackWebhookUrl = https://xxxxx.lambda-url.ap-northeast-1.on.aws/webhook/slack

// ===========================================
// durable function Lambda
// ===========================================
const durableFunctionName = "backlog-completion-durable";

const durableFunction = new nodejs.NodejsFunction(this, "DurableFunction", {
  functionName: durableFunctionName,
  runtime: lambda.Runtime.NODEJS_22_X,
  entry: path.join(serverSrcPath, "handler/durable/handler.ts"),
  handler: "handler",
  timeout: cdk.Duration.seconds(30),
  memorySize: 1024,
  architecture: lambda.Architecture.ARM_64,
+  // durable functionsの設定
+  durableConfig: {
+    executionTimeout: cdk.Duration.days(1),  // 最大24時間待機可能
+    retentionPeriod: cdk.Duration.days(7),   // 実行履歴を7日間保持
+  },
});

// ===========================================
// API Lambda (Monolithic - Hono)
// Backlog/Slack Webhook受信を1つのLambdaで処理
// ===========================================
const apiFunctionName = "backlog-completion-api";

const apiFunction = new nodejs.NodejsFunction(this, "ApiFunction", {
  functionName: apiFunctionName,
  runtime: lambda.Runtime.NODEJS_22_X,
  entry: path.join(serverSrcPath, "handler/api/handler.ts"),
  handler: "handler",
  timeout: cdk.Duration.seconds(30),
  memorySize: 512,
  architecture: lambda.Architecture.ARM_64,
  environment: {
    DURABLE_FUNCTION_NAME: durableFunctionName,
  },
});

// Function URLでAPIを公開
const apiFunctionUrl = apiFunction.addFunctionUrl({
  authType: lambda.FunctionUrlAuthType.NONE,
});

// durable functionにBedrock呼び出し権限を付与
durableFunction.addToRolePolicy(
  new iam.PolicyStatement({
    actions: ["bedrock:InvokeModel"],
    resources: ["*"],
  })
);

// API Lambdaがdurable functionを呼び出す権限
durableFunction.grantInvoke(apiFunction);

+// API Lambdaがdurable functionのコールバックを送信する権限
+apiFunction.addToRolePolicy(
+  new iam.PolicyStatement({
+    actions: [
+      "lambda:SendDurableExecutionCallbackSuccess",
+      "lambda:SendDurableExecutionCallbackFailure",
+    ],
+    resources: [
+      durableFunction.functionArn,
+      `${durableFunction.functionArn}:*`,
+    ],
+  })
+);

async execute(input: HandleBacklogWebhookInput): Promise<HandleBacklogWebhookOutput> {
  // 課題更新イベント以外は無視
  if (input.type !== BacklogEventType.ISSUE_UPDATED) {
    return {
      status: "ignored",
      reason: "Not an issue update event",
    };
  }

  // 課題が完了状態でなければ無視
  if (!isIssueCompleted(input)) {
    return {
      status: "ignored",
      reason: "Issue is not completed",
    };
  }

+  // durable functionを起動
+ await this.#durableFunctionClient.invoke({
+   issueKey,
+   projectKey: input.project.projectKey,
+   issueSummary: input.issue.summary,
+   issueDescription: input.issue.description || "",
+ });

  return { status: "invoked", issueKey };
}

async execute(
  input: ProcessIssueCompletionInput,
  context: DurableContext
): Promise<ProcessIssueCompletionOutput> {
  const { issueKey } = input;

+  // Step 1: 課題詳細とコメントを取得
  const issueDetails = await context.step("fetch-issue-details", async () => {
    const [issue, comments] = await Promise.all([
      this.#backlogRepository.getIssue(issueKey),
      this.#backlogRepository.getComments(issueKey),
    ]);
    return { /* 課題情報 */ };
  });

+  // Step 2: サマリーを生成
  const summary = await context.step("generate-summary", async () => {
    const prompt = buildCompletionSummaryPrompt({
      issueKey: issueDetails.issueKey,
      issueSummary: issueDetails.issueSummary,
      issueDescription: issueDetails.issueDescription,
      comments: issueDetails.comments,
    });
    return this.#summaryGenerator.generate(prompt);
  });

+  // Step 3: コールバックを作成
  const [callbackPromise, callbackId] = await context.createCallback("approval", {
    timeout: { hours: 24 },
  });

+  // Step 4: Slack承認リクエストを送信
  await context.step("send-approval-request", async () => {
    const message = buildApprovalMessage({
      channel: this.#slackChannelId,
      issueKey: issueDetails.issueKey,
      summary,
      callbackId,
    });
    await this.#slackNotifier.postMessage(message);
  });

+  // ここで待機（コンピュート料金なし）
  const result = await callbackPromise;
  // ...後続処理
}

elements: [
  {
    type: "button",
    text: { type: "plain_text", text: "承認して投稿" },
    style: "primary",
    action_id: "approve",
    value: JSON.stringify({
+      callbackId,  // ここでコールバックIDを渡す
      approved: true,
    }),
  },
  {
    type: "button",
    text: { type: "plain_text", text: "却下" },
    style: "danger",
    action_id: "reject",
    value: JSON.stringify({
+      callbackId,
      approved: false,
    }),
  },
],

async execute(input: HandleSlackWebhookInput): Promise<HandleSlackWebhookOutput> {
  const { callbackId, approved, userName } = input;

  if (approved) {
+    await this.#durableFunctionClient.sendCallbackSuccess(callbackId, {
      approved: true,
      approvedBy: userName,
      approvedAt: this.#fetchNow().toISOString(),
+    });
  } else {
+    await this.#durableFunctionClient.sendCallbackFailure(callbackId, {
      rejectedBy: userName,
+    });
  }

  return buildApprovalResponse({ approved, userName });
}

+// callbackPromiseが解決された後の処理
try {
  const result = await callbackPromise;
  approval = JSON.parse(result) as CallbackResult;
} catch {
+  // 却下またはタイムアウト
  await context.step("send-rejection-notification", async () => {
    await this.#slackNotifier.postMessage(/* 却下通知 */);
  });
  return { issueKey, status: "rejected", summary };
}

// 承認時の処理
if (approval.approved) {
+  // Step 5: Backlogにコメント投稿
  await context.step("post-backlog-comment", async () => {
    const comment = buildBacklogComment({ summary });
    await this.#backlogRepository.addComment(issueKey, comment);
  });

+  // Step 6: Slackに完了通知
  await context.step("send-completion-notification", async () => {
    await this.#slackNotifier.postMessage(/* 完了通知 */);
  });
}

return { issueKey, status: "completed", approved: approval.approved, summary };

[障害発生 or wait/callback完了]
        ↓
[関数を最初から再実行（リプレイ）]
        ↓
[完了済み step はスキップ、保存結果を使用]
        ↓
[未完了の処理から再開]

backlog-completion-notifier/
├── infra/                              # CDKインフラコード
│   ├── bin/infra.ts
│   ├── lib/stack/server-stack.ts       # Lambda定義
│   ├── lib/util/ssm.ts                 # SSMパラメータ取得
│   ├── config.ts                       # 設定値
│   └── config-type.ts                  # 設定型定義
└── server/                             # サーバーコード
    └── src/
        ├── handler/
        │   ├── api/                    # API Lambda
        │   │   ├── handler.ts
        │   │   ├── app.ts              # Honoアプリ
        │   │   └── route/webhook/      # Webhookハンドラー
        │   └── durable/                # durable function
        │       └── handler.ts
        ├── use-case/                   # ユースケース層
        │   ├── handle-backlog-webhook/
        │   ├── handle-slack-webhook/
        │   └── process-issue-completion/
        ├── domain/                     # ドメイン層
        │   ├── model/backlog/          # Backlog関連型定義
        │   ├── support/                # インターフェース
        │   └── template/               # テンプレート（Slack、プロンプト）
        ├── infrastructure/             # インフラ層
        │   ├── backlog-client.ts
        │   ├── bedrock-client.ts
        │   ├── slack-client.ts
        │   └── lambda-durable-function-client.ts
        └── di-container/               # 依存性注入
            └── register-container.ts