DevRev Snap-in で Ticket のコメントから自動で Article を作成する

devrev-snaps-typescript-template/
├── manifest.yaml                          # イベントソースと関数の定義
└── code/
    ├── package.json
    ├── tsconfig.json
    └── src/
        ├── function-factory.ts            # 関数の登録
        ├── index.ts
        └── functions/
            └── on_work_creation/          # テンプレートの関数 (後で差し替え)
                └── index.ts

version: "2"
name: "Ticket to Article"
description: "Ticket のステージが resolved に変更されたとき Article を作成する"

service_account:
  display_name: DevRev Bot

event_sources:
  organization:
    - name: devrev-event-source
      description: Ticket のステージ変更を監視するイベントソース
      display_name: Ticket stage change listener
      type: devrev-webhook
      config:
        event_types:
          - work_updated

functions:
  - name: on_ticket_resolved
    description: Ticket が resolved になったときに Article を作成する関数

automations:
  - name: handle-ticket-resolved
    source: devrev-event-source
    event_types:
      - work_updated
    function: on_ticket_resolved

function extractUrl(text: string): string | null {
  const urlRegex = /https?:\/\/[^\s<>"{}|\\^`\[\]]+/g;
  const matches = text.match(urlRegex);
  return matches ? matches[0] : null;
}

export async function handleEvent(event: any) {
  const devrevPAT = event.context.secrets.service_account_token;
  const APIBase = event.execution_metadata.devrev_endpoint;
  const devrevSDK = client.setup({
    endpoint: APIBase,
    token: devrevPAT,
  });

  const payload = event.payload;
  const work = payload.work_updated.work;

  // Ticket かつ work_in_progress → resolved の遷移のみ処理
  if (work.type !== "ticket") return;
  if (work.stage?.name !== "resolved") return;
  if (payload.work_updated.old_work?.stage?.name !== "work_in_progress") return;

  const url = extractUrl(work.body || "");
  // ... URL 先のコンテンツを取得し Article を作成
}

function extractDevClassmethodUrl(text: string): string | null {
  const regex = /https?:\/\/dev\.classmethod\.jp\/[^\s<>"{}|\\^`\[\]]*/g;
  const matches = text.match(regex);
  return matches ? matches[matches.length - 1] : null;
}

async function findLastDevClassmethodUrl(
  devrevSDK: publicSDK.Api<unknown>,
  workId: string
): Promise<string | null> {
  let lastUrl: string | null = null;
  let cursor: string | undefined = undefined;

  do {
    const request: publicSDK.TimelineEntriesListRequest = {
      object: workId,
      limit: 50,
      visibility: [
        publicSDK.TimelineEntryVisibility.Public,
        publicSDK.TimelineEntryVisibility.External,
      ],
      ...(cursor ? { cursor, mode: publicSDK.ListMode.After } : {}),
    };

    const response = await devrevSDK.timelineEntriesListPost(request);
    const entries = response.data?.timeline_entries || [];

    for (const entry of entries) {
      const body = (entry as any).body;
      if (typeof body === "string") {
        const found = extractDevClassmethodUrl(body);
        if (found) {
          lastUrl = found;
        }
      }
    }

    cursor = response.data?.next_cursor || undefined;
  } while (cursor);

  return lastUrl;
}

function parseHtml(html: string): { title: string; body: string } {
  const titleMatch = html.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
  const title = titleMatch ? titleMatch[1].trim() : "Untitled";

  const articleMatch = html.match(/<article[^>]*>([\s\S]*?)<\/article>/i);
  const bodyMatch = html.match(/<body[^>]*>([\s\S]*?)<\/body>/i);

  let rawBody = articleMatch ? articleMatch[1] : (bodyMatch ? bodyMatch[1] : "");

  const body = rawBody
    .replace(/<script[^>]*>[\s\S]*?<\/script>/gi, "")
    .replace(/<style[^>]*>[\s\S]*?<\/style>/gi, "")
    .replace(/<[^>]+>/g, "")
    .replace(/\s+/g, " ")
    .trim();

  return { title, body };
}

// Article 作成
const articleRequest: publicSDK.ArticlesCreateRequest = {
  title: title,
  description: body,
  owned_by: [work.owned_by?.[0]?.id || work.created_by?.id],
  resource: { url: url },
  status: publicSDK.ArticleStatus.Published,
};
const articleResponse = await devrevSDK.createArticle(articleRequest);