interface UploadNewImageUseCaseDependencies {
  imageStoreRepo: ImageStoreRepo
  imageMetadataRepo: ImageMetadataRepo
}

export function uploadNewImageUseCase(deps: UploadNewImageUseCaseDependencies) {
  return async (
    imageData: ArrayBuffer,
    metadata: {
      prompt: ImagePrompt
      modelName: string
      createdAt?: Date
      imageExtension: string
    },
  ) => {
    // ここからロジック
    const { prompt, modelName, createdAt = new Date(), imageExtension: ext } = metadata
    const filename = `${format(createdAt, 'yyyy-MM-dd-HH-mm-ss')}${ext}`

    const imageUri = await deps.imageStoreRepo.upload(filename, imageData)
    try {
      const metadataRecord = { id: uuidv7(), prompt, modelName, createdAt, imageUri }
      await deps.imageMetadataRepo.add(metadataRecord)
    } catch (e) {
      console.error(e)
      await deps.imageStoreRepo.delete(filename)
      throw e
    }
  }
}

export function uploadNewImageUseCase(deps: UploadNewImageUseCaseDependencies) {
  return async (...args) => {
    // 依存注入後の関数
  }
}

export interface ImageStoreRepo {
  upload: (filename: string, imageData: ArrayBuffer) => Promise<string> // 戻り値はURI
  download: (filename: string) => Promise<ArrayBuffer> // 画像データを取得
  delete: (filename: string) => Promise<void> // 画像データを削除
}

import { getContext } from 'hono/context-storage'
import { ImageStoreRepo } from '../../domain/repos/image-store-repo'

export const imageStoreRepoCloudflareR2: ImageStoreRepo = { // ImageStoreRepo を実装
  upload: async (filename: string, imageData: ArrayBuffer) => {
    const c = getContext<Env>()
    const filePath = toR2Key(filename)
    await c.env.BUCKET.put(filePath, imageData)
    return `https://media.trpfrog.net/${filePath}`
  },

  download: async (filename: string) => {
    const c = getContext<Env>()
    const filePath = toR2Key(filename)
    const res = await c.env.BUCKET.get(filePath)
    if (res === null) {
      throw new Error('Not found')
    }
    return await res.arrayBuffer()
  },

  delete: async (filename: string) => {
    const c = getContext<Env>()
    const filePath = toR2Key(filename)
    await c.env.BUCKET.delete(filePath)
  },
}

import { UseCases } from '../wire'

export function createApp(ucs: UseCases) {
  return new Hono<Env>()
    // ...
    .get('/current', async c => {
      const arrayBuffer = await ucs.currentImage()
      return c.newResponse(arrayBuffer)
    })
    // ...
}

import { z } from 'zod'

import { createApp } from './controller'
import { prepareUsecasesBuilder } from './wire'

// インフラ層の実装
import { imageMetadataRepoCloudflareD1WithKV } from './infra/repos/imageMetadataRepoCloudflareD1WithKV'
import { imageStoreRepoCloudflareR2 } from './infra/repos/imageStoreRepoCloudflareR2'
import { createOpenAIChatLLMJson } from './infra/services/llm'
import { randomWordApi } from './infra/services/random-words'
import { createHfImageGenerator } from './infra/services/text-to-image'

const env = z
  .object({
    HUGGINGFACE_TOKEN: z.string(),
    OPENAI_API_KEY: z.string(),
  })
  // eslint-disable-next-line n/no-process-env
  .parse(process.env)

const app = createApp(
  prepareUsecasesBuilder({
    imageStoreRepo: imageStoreRepoCloudflareR2,
    imageMetadataRepo: imageMetadataRepoCloudflareD1WithKV,
    textToImage: createHfImageGenerator({
      modelName: 'Prgckwb/trpfrog-sd3.5-large-lora',
      hfToken: env.HUGGINGFACE_TOKEN,
    }),
    jsonChatbot: createOpenAIChatLLMJson({
      model: 'gpt-4o-2024-11-20',
      temperature: 0.9,
      apiKey: env.OPENAI_API_KEY,
    }),
    generateSeedWords: () => randomWordApi(10),
  })
)

import * as rawUsecases from './usecases'

// 共通の依存関係を受け取る型を定義
type CommonDependencies = {
  imageStoreRepo: ImageStoreRepo
  imageMetadataRepo: ImageMetadataRepo
  textToImage: TextToImage
  jsonChatbot: ChatLLMJson
  generateSeedWords: () => Promise<string[]>
}

// ユースケースを手動で組み立てる関数
export function prepareUsecasesBuilder(common: CommonDependencies): UseCases {
  const { imageStoreRepo, imageMetadataRepo, textToImage, jsonChatbot, generateSeedWords } = common

  // 基本的なユースケースのインスタンスを作成
  const currentImage = rawUsecases.currentImageUseCase({ imageMetadataRepo, imageStoreRepo })
  const currentMetadata = rawUsecases.currentMetadataUseCase({ imageMetadataRepo })
  const generateImage = rawUsecases.generateImageUseCase({ textToImage })
  const generatePromptFromWords = rawUsecases.generatePromptFromWordsUseCase({ jsonChatbot })
  const generateRandomWords = rawUsecases.generateRandomWordsUseCase({ generateSeedWords })
  const uploadNewImage = rawUsecases.uploadNewImageUseCase({ imageMetadataRepo, imageStoreRepo })
  const queryImageMetadata = rawUsecases.queryImageMetadataUseCase({ imageMetadataRepo })

  // 依存関係を持つ派生ユースケースのインスタンスを作成
  const generateRandomImage = rawUsecases.generateRandomImageUseCase({
    generateImage: (prompt: string) => generateImage(prompt, { numberOfRetries: 3 }),
    generatePromptFromSeedWords: (seedWords: string[]) => generatePromptFromWords(seedWords),
    generateSeedWords: generateRandomWords,
  })

  const refreshImageIfStale = rawUsecases.refreshImageIfStaleUseCase({
    imageMetadataRepo,
    uploadImage: uploadNewImage,
    imageGenerator: generateRandomImage,
  })

  return {
    currentImage,
    currentMetadata,
    generateImage,
    generatePromptFromWords,
    generateRandomWords,
    uploadNewImage,
    queryImageMetadata,
    generateRandomImage,
    refreshImageIfStale,
  }
}

.
├── README.md
├── drizzle.config.ts
├── eslint.config.mjs
├── package.json
├── bin/
├── coverage/
├── migrations/
├── src
│   ├── index.ts     # サービスのエントリーポイント
│   ├── client.ts    # 他のサービスからこれを叩くための RPC クライアントを export している
│   ├── env.ts       # Hono の Bindings などを定義している
│   ├── wire.ts      # 依存性注入をする
│   ├── lib/         # 雑多な便利関数など
│   ├── controller/  # Hono のルータが入っている
│   ├── domain/      # このサービス内で使うインタフェース等のドメインモデルが入っている
│   ├── infra/       # このサービスが外部とやり取りするためのインフラ実装が入っている
│   └── usecases/    # ユースケースが入っている
├── tsconfig.json
├── vitest.config.mjs
├── worker-configuration.d.ts
└── wrangler.toml

POST /ai-icons?page=1 HTTP/1.1  // [!code highlight]
Accept: text/x-component
Accept-Encoding: gzip, deflate, br, zstd
Accept-Language: ja,en-US;q=0.9,en;q=0.8
Connection: keep-alive
Content-Length: 12
Content-Type: text/plain;charset=UTF-8
DNT: 1
Host: localhost:3000
Next-Action: 4095e2f27064b885a81d811909608cea68ed03a177   // [!code highlight]
Next-Router-State-Tree: /* 略 */
Origin: http://localhost:3000
Referer: http://localhost:3000/ai-icons?page=1
Sec-Fetch-Dest: empty
Sec-Fetch-Mode: cors
Sec-Fetch-Site: same-origin
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36
sec-ch-ua: "Chromium";v="131", "Not_A Brand";v="24"
sec-ch-ua-mobile: ?0
sec-ch-ua-platform: "macOS"

0:{"a":"$@1","f":"","b":"development"}
1:{
  "result": [
    {
      "id": "0193ea5d-3bad-78ec-ba88-0fc65fea24be",
      "prompt": {
        "author": "gpt-4o-2024-11-20",
        "text": "an icon of trpfrog balancing saddlebags in a neon-lit dystopian world",
        "translated": "ネオンに照らされたディストピア世界で鞍袋をバランスよく持つつまみさんの画像"
      },
      "modelName": "Prgckwb/trpfrog-sd3.5-large-lora",
      "createdAt": "2024-12-21T17:56:37.503Z",
      "imageUri": "https://media.trpfrog.net/ai-icons/2024-12-21-17-56-37.jpeg"
    },
    /* 以下省略 */
  ],
  "total": 34,
  "numPages": 2
}

export function createApp(ucs: UseCases) {
  return new Hono<Env>()
    .basePath(services.imageGeneration.basePath)
    .use(contextStorage())
    .use(prettyJSON())
    .use(trimTrailingSlash())
    .use(cors())
    .get('/current', async c => {
      const arrayBuffer = await ucs.currentImage() 
      return c.newResponse(arrayBuffer)
    })
    .get('/current/metadata', async c => {
      const data = await ucs.currentMetadata() 
      if (data == null) {
        return c.json({ error: 'No metadata found' }, 404)
      }
      return c.json(data)
    })
    .post('/update', requiresApiKey(), async c => {
      const result = await ucs.refreshImageIfStale({ 
        forceUpdate: c.req.query('force') === 'true',      
      })                                                   
      return result.updated
        ? c.json({ status: 'updated' }, 201) // 201 Created
        : c.json({ status: 'skipped', message: result.message })
    })

export async function fetchImageRecords(query: { page: number })

[{"page":1}]   

curl -X POST http://localhost:3000/ai-icons \
  -H "Content-Type: text/plain;charset=UTF-8" \
  -H "Next-Action: 4095e2f27064b885a81d811909608cea68ed03a177" \
  -d '[{"page":1}]'

const app = new Hono()
  .get('/current', async c => {
    // `c.env.BUCKET` で R2 にアクセスできる
    const arrayBuffer = await c.env.BUCKET.get('current')  
    return c.newResponse(arrayBuffer)
  })

import { contextStorage } from 'hono/context-storage'

const app = new Hono()
  .use(contextStorage()) 
  .get('/current', async c => {
    // ...
  })

import { getContext } from 'hono/context-storage'

export const imageStoreRepoCloudflareR2: ImageStoreRepo = {
  upload: async (filename: string, imageData: ArrayBuffer) => {
    const c = getContext<Env>() 
    const filePath = toR2Key(filename)
    await c.env.BUCKET.put(filePath, imageData)
    // ...
  },
  // ...
}