LINE の友だち登録経路を拾える仕組みを考えてみた

    ：
-const App = () => {
+interface AppProps {
+  paramHomeScreen: string;
+  paramRegisteredSource: string;
+}
+export const App: FC<AppProps> = ({ paramHomeScreen, paramRegisteredSource }) => {
  // 開始メッセージ構築
  // クエリーパラメータ有り、かつ URL 指定起動（更新や戻るで移動していない）のものを選別
  const startMessage = (paramHomeScreen !== "" && isNavigateAccess()) ?
    "Started from home screen..." :
    "Started from direct access...";

  const [message, setMessage] = useState(startMessage);
  const [error, setError] = useState("no error");

  const handleClick = () => {
    // ショートカット URL 作成（クエリーパラメータ付与）
    liff.createShortcutOnHomeScreen({ url: `https://miniapp.line.me/${import.meta.env.VITE_LIFF_ID}?createHomeScreen=1` })
    .then(() => {
      setMessage("createShortcutOnHomeScreen succeeded.");
    })
    .catch((e: Error) => {
      console.log(e);
      setMessage("createShortcutOnHomeScreen failed.");
      setError(`${e}`);
    });
  }
+
+  const handleRegisterClick = async () => {
+    // LINE アクセストークン取得
+    const lineAccessToken = liff.getAccessToken();
+    // あった場合（ない場合はログインされていないので何もしない）
+    if (lineAccessToken) {
+      try {
+        const responsePreRegister = await axios.post(`${import.meta.env.VITE_PREREGISTER_API_URL}`, {
+          lineAccessToken, registeredSource: paramRegisteredSource
+        });
+        if (responsePreRegister.status === 200) {
+          // LINE 友だち登録（ブロック解除）起動
+          liff.openWindow({
+            url: `${import.meta.env.VITE_REGISTER_LINE_URL}`,
+            external: false
+          });
+        } else {
+          console.log(responsePreRegister);
+          throw ("preregister error!");
+        }
+      } catch (e) { 
+        console.log("error catch!!!");
+        if (e instanceof Error) {
+          console.log(e);
+          setError(e.message);
+        }
+      }
+    } else {
+      if (lineAccessToken == null) {
+        setError("I don't have a LINE Access Token.");
+      } else {
+        setError("You are already friends.");
+      }
+    }
+  }

  return (
    <div className="App">
      <h1>Liff Lambda Test App</h1>
      {message && <p>{message}</p>}
      <p>
        <button onClick={handleClick}>リンクを作成</button>
+        <button onClick={handleRegisterClick}>LINE へ友だち登録</button>
      </p>
      {error && (
        <p> 
          <code>{error}</code>
        </p>
      )}  
    </div>
  );
}
    ：

export interface FriendRegister {
  lineUserId: string
  registerFrom: string
  registerStatus: string
}

export type FriendRegisters = ReadonlyArray<FriendRegister>;

import { FriendRegister, FriendRegisters } from "./friendRegister";

export type FriendRegisterResult = FriendRegister | undefined;
export type FriendRegistersResult = FriendRegisters;

export interface FriendRegisterRepository {
	getAll(): Promise<FriendRegistersResult>;
	getItemFromId(lineUserId: string): Promise<FriendRegisterResult>;
	putItem(item: FriendRegister): Promise<void>;
	deleteItem(lineUserId: string): Promise<void>;
}

import {
  DynamoDBDocumentClient,
  ScanCommand,
  QueryCommand,
  PutCommand,
  DeleteCommand
} from "@aws-sdk/lib-dynamodb";
import { FriendRegister } from "@/domain/model/friendRegister/friendRegister";
import {
	FriendRegisterResult,
	FriendRegistersResult,
	FriendRegisterRepository
} from "@/domain/model/friendRegister/friendRegister-repository";

export class FriendRegisterDBRepository implements FriendRegisterRepository {
  private readonly dbDocument: DynamoDBDocumentClient;
  private readonly friendRegisterTableName: string;

  constructor({
    dbDocument,
    friendRegisterTableName,
  }: {
    dbDocument: DynamoDBDocumentClient,
    friendRegisterTableName: string,
  }) {
    this.dbDocument = dbDocument;
    this.friendRegisterTableName = friendRegisterTableName;
  }

  private setItem(item: Record<string, any>): FriendRegister {
    const element: FriendRegister = {
      lineUserId: item["lineUserId"] || "",
      registerFrom: item["registerFrom"] || "",
      registerStatus: item["registerStatus"] || "",
    };
    return element
  }

  async getAll(): Promise<FriendRegistersResult> {
    const command = new ScanCommand({
      TableName: this.friendRegisterTableName,
    });
    const { Items: items = [] } = await this.dbDocument.send(command);
    const scanItems: FriendRegister[] = [];
    items.map((item) => {
      scanItems.push(this.setItem(item));
    });
    return scanItems;
  }

  async getItemFromId(lineUserId: string): Promise<FriendRegisterResult> {
    const command = new QueryCommand({
      TableName: this.friendRegisterTableName,
      KeyConditionExpression: "lineUserId = :userid",
      ExpressionAttributeValues: { ":userid": lineUserId },
      ScanIndexForward: false,
    });
    const { Items: items = [] } = await this.dbDocument.send(command);
    if (items.length === 0) {
      return undefined;
    }
    return this.setItem(items[0]);
  }

  async putItem(item: FriendRegister): Promise<void> {
    const command = new PutCommand({
      TableName: this.friendRegisterTableName,
      Item: {
        lineUserId: item.lineUserId,
        registerFrom: item.registerFrom,
        registerStatus: item.registerStatus,
      },
    });
    try {
      const res = await this.dbDocument.send(command);
      console.log("putcommand res : ", res);
    } catch (error) {
      console.error("putItem :", error);
    }
  }

  async deleteItem(lineUserId: string): Promise<void> {
    const command = new DeleteCommand({
      TableName: this.friendRegisterTableName,
      Key: {
        lineUserId: lineUserId,
      },
    });
    try {
      await this.dbDocument.send(command);
    } catch (error) {
      console.error("deleteItem :", error);
    }
  }
}```

import { ID_REGISTER_API_USE_CASE, initContainer } from "@/di-container/register-container";
import { RegisterApiUseCase, UnexpectedError } from "@/use-case/liff-app-use-case/use-case";
import { APIGatewayProxyResult, APIGatewayProxyEvent, Context } from "aws-lambda";

const resultOK: APIGatewayProxyResult = {
  statusCode: 200,
  body: JSON.stringify({}),
}

const resultError: APIGatewayProxyResult = {
  statusCode: 500,
  body: JSON.stringify({}),
}

export const handler = async (event: APIGatewayProxyEvent, context: Context) => {
  console.log("event : ", event);
  console.log("context : ", context);

  const container = initContainer();
  const { lineAccessToken, registeredSource } = JSON.parse(event.body!);
  console.log("parameters : ", lineAccessToken, ", ", registeredSource);

  const execRegisterApiUseCase = container.get<RegisterApiUseCase>(ID_REGISTER_API_USE_CASE);
  const resultUseCase = await execRegisterApiUseCase(lineAccessToken || "", decodeURIComponent(registeredSource || ""));
  if (resultUseCase instanceof UnexpectedError) {
    console.error("予期しないエラーが発生");
    return resultError;
  }
  return resultOK;
}

import { FriendRegisterRepository } from "@/domain/model/friendRegister/friendRegister-repository";
import axios from "axios";

export class UnexpectedError extends Error { }
export type RegisterApiUseCaseResult =
  | void
  | UnexpectedError;

const DEF_LINE_API_VERIFY_URL = "https://api.line.me/oauth2/v2.1/verify";
const DEF_LINE_API_PROFILE_URL = "https://api.line.me/v2/profile";

export type RegisterApiUseCase = (
  lineAccessToken: string,
  registerFrom: string,
) => Promise<RegisterApiUseCaseResult>;

export const execRegisterApiUseCase = ({
  friendRegisterRepository,
}: {
  friendRegisterRepository: FriendRegisterRepository,
}): RegisterApiUseCase => async (lineAccessToken: string, registerFrom: string): Promise<RegisterApiUseCaseResult> => {
  if (lineAccessToken === "") {
    console.log("LINE Access Token is null.");
    return new UnexpectedError();
  }
  try {
    const verifyResponse = await axios.get(DEF_LINE_API_VERIFY_URL, {
      params: { access_token: lineAccessToken },
    });
    if (verifyResponse.status === 200) {
      console.log("call profile");
      const userInfoResponse = await axios.get(DEF_LINE_API_PROFILE_URL, {
        headers: {
          Authorization: `Bearer ${lineAccessToken}`,
        }
      });
      const lineUserId = userInfoResponse.data.userId;
      await friendRegisterRepository.putItem({
        lineUserId,
        registerFrom,
        registerStatus: "READY",
      });
    } else {
      console.log("not 200 response : ", verifyResponse);
      return new UnexpectedError();
    }
  } catch (err) {
    if (err instanceof Error) {
      console.log("err : ", err);
    }
    return new UnexpectedError();
  }
  return undefined;
}

    ：
import { execLineBotUseCase } from '@/use-case/line-bot-use-case/use-case';
+import { FriendRegisterDBRepository } from '@/infrastracture/repository/friendRegister-dynamodb-repository';
import { execRegisterApiUseCase } from '@/use-case/liff-app-use-case/use-case';
    ：
export const ID_TABLE_NAME = "ID_TABLE_NAME" as const;
+export const ID_TABLE_NAME_LIFF_APP = "ID_TABLE_NAME_LIFF_APP" as const;
export const ID_BUCKET_NAME = "ID_BUCKET_NAME" as const;
    ：
export const ID_MEMO_STORE_REPOSITORY = "ID_MEMO_STORE_REPOSITORY" as const;
+export const ID_IMAGE_CRAFT_REPOSITORY = "ID_IMAGE_CRAFT_REPOSITORY" as const;
+export const ID_LINE_BOT_USE_CASE = "ID_LINE_BOT_USE_CASE" as const;
    ：
export const initContainer = (): Container => {
  const container = new Container();
    ：
  container
    .bind(ID_TABLE_NAME)
    .toDynamicValue(() => process.env.TABLE_NAME || "")
    .inSingletonScope();
+ container
+   .bind(ID_TABLE_NAME_LIFF_APP)
+   .toDynamicValue(() => process.env.TABLE_NAME_LIFF_APP || "")
+   .inSingletonScope();
  container
    .bind(ID_BUCKET_NAME)
    .toDynamicValue(() => process.env.BUCKET_NAME || "")
    .inSingletonScope();
    ：
  container
    .bind(ID_IMAGE_CRAFT_REPOSITORY)
    .toDynamicValue((context) => 
      new ImageCraftRepositoryImpl({
        bedrock: context.container.get<BedrockRuntimeClient>(ID_BEDROCK),
        s3: context.container.get<S3Client>(ID_S3),
        bucketName: context.container.get<string>(ID_BUCKET_NAME),
      })
    )
    .inSingletonScope();
+ container
+   .bind(ID_FRIEND_REGISTER_REPOSITORY)
+   .toDynamicValue((context) =>
+     new FriendRegisterDBRepository({
+       dbDocument: context.container.get<DynamoDBDocumentClient>(ID_DYNAMODB_DOCUMENT),
+       friendRegisterTableName: context.container.get<string>(ID_TABLE_NAME_LIFF_APP),
+     })
+   )
+   .inSingletonScope();
  // LINE ボットユースケース
  container
    .bind(ID_LINE_BOT_USE_CASE)
    .toDynamicValue(async (context) =>
      execLineBotUseCase({
        lineBotClient: await context.container.getAsync<LineBotImpl>(ID_LINE_BOT),
        memoStoreRepository: context.container.get<MemoStoreDynamoDBRepository>(ID_MEMO_STORE_REPOSITORY),
        imageCraftRepository: context.container.get<ImageCraftRepositoryImpl>(ID_IMAGE_CRAFT_REPOSITORY),
        friendRegisterRepository: context.container.get<FriendRegisterDBRepository>(ID_FRIEND_REGISTER_REPOSITORY),
      })
    )
    .inSingletonScope();
+ container
+   .bind(ID_REGISTER_API_USE_CASE)
+   .toDynamicValue((context) =>
+     execRegisterApiUseCase({
+       friendRegisterRepository: context.container.get<FriendRegisterDBRepository>(ID_FRIEND_REGISTER_REPOSITORY),
+     })
+   )
+   .inSingletonScope();

  return container;
}

import { execRegisterCommand, execListCommand, execDeleteCommand, execAskCommand, ReplyMessage, ReplyMessages } from "./dispatchCommand";
+import { FriendRegisterRepository} from "@/domain/model/friendRegister/friendRegister-repository";
    ：
+const dispatchFollowEvent = async ({
+ webhookEvent,
+ friendRegisterRepository,
+}: {
+ webhookEvent: WebhookEvent,
+ friendRegisterRepository: FriendRegisterRepository,
+}): Promise<ReplyMessage | undefined> => {
+ const lineUserId = webhookEvent.source.userId || "";
+ const friendRegister = await friendRegisterRepository.getItemFromId(lineUserId);
+ const fromPlace = (friendRegister != null) ? friendRegister.registerFrom : "通常の友だち登録";
+ if (webhookEvent.type === "follow") {
+   const followEvent: FollowEvent = (webhookEvent as FollowEvent);
+   if (followEvent.follow != null) {
+     if (friendRegister != null) {
+       await friendRegisterRepository.putItem({
+         lineUserId: friendRegister.lineUserId,
+         registerFrom: friendRegister.registerFrom,
+         registerStatus: "FRIEND REGISTERED",
+       });
+     }
+     // アンロックからの復帰応答を設定
+     if (followEvent.follow.isUnblocked === true) {
+       return {
+         type: "text",
+         text: `${fromPlace} より、おかえりなさいませ！`,
+       };
+     // それ以外は新規追加としてイベント応答を設定
+     } else {
+       return {
+         type: "text",
+         text: `${fromPlace} より、いらっしゃいませ！`,
+       };
+     }
+   }
+ } else {
+   friendRegisterRepository.deleteItem(lineUserId);
+ }
+ return undefined
+}
    ：
/**
 * event ディスパッチ処理
 * @param webhookEvent : event インスタンス
 * @param lineBotClient : LINE の Messaging API 等実行インスタンス
 * @param memoStoreRepository : memoStore データリポジトリ
 * @param imageCraftRepository : imageCraft データリポジトリ
+* @param friendRegisterRepository : FriendRegister データリポジトリ
 * @returns ExecWebhookEventResult 戻り値（エラーインスタンス、エラー無しの場合は undefined）
 */
const dispatchEvent = async({
    ：
    const commandResult: ReplyMessages = [];
    // フォローイベント
-   if (webhookEvent.type === "follow") {
-     const followEvent: FollowEvent = (webhookEvent as FollowEvent);
-     if (followEvent.follow != null) {
-       if (followEvent.follow.isUnblocked === true) {
-         commandResult.push({
-           type: "text",
-           text: "おかえりなさいませ！",
-         });
-       } else {
-         commandResult.push({
-           type: "text",
-           text: "いらっしゃいませ！",
-         });
-       }
-     }
+  if (webhookEvent.type === "follow" || webhookEvent.type === "unfollow") {
+     const replyMessage = await dispatchFollowEvent({ webhookEvent, friendRegisterRepository });
+     if (replyMessage != null) {
+       console.log(replyMessage);
+       commandResult.push(replyMessage);
+     }
    } else if (webhookEvent.type === "message" && webhookEvent.message.type === "text") {
    ：