@aiquants/daily-report 0.1.1

package/src/server/sse-reader.spec.ts

@@ -0,0 +1,55 @@
+import { describe, expect, it, vi } from "vitest"
+import { createEpochStore, SqlResultCache } from "./cache"
+import type { DailyReportRedisProvider } from "./ports"
+import { DailyReportSseReader, isStreamIdLte } from "./sse-reader"
+
+/**
+ * Robustness tests for the SSE fan-out reader (createClient failure recovery + id compare).
+ * SSE Fan-Out リーダーの堅牢性テスト (createClient 失敗時の復帰 + Stream ID 比較)。
+ */
+
+const makeCache = () => new SqlResultCache({ defaultTtlMs: 1000 }, createEpochStore(undefined))
+
+describe("isStreamIdLte", () => {
+    it("数値比較で ms / seq を正しく順序付ける (辞書順の罠を回避)", () => {
+        expect(isStreamIdLte("100-0", "100-0")).toBe(true)
+        expect(isStreamIdLte("100-2", "100-10")).toBe(true) // 辞書順なら false になる罠
+        expect(isStreamIdLte("101-0", "100-9")).toBe(false)
+    })
+})
+
+describe("DailyReportSseReader createClient failure recovery", () => {
+    it("createClient が reject しても _state が stuck せず、再購読でループを再開できる", async () => {
+        let attempts = 0
+        const redis: DailyReportRedisProvider = {
+            getClient: async () => undefined,
+            // 1 回目は例外を投げ、2 回目は undefined を返す (どちらも復帰可能であること)
+            createClient: async () => {
+                attempts++
+                if (attempts === 1) throw new Error("connection refused")
+                return undefined
+            },
+        }
+        const reader = new DailyReportSseReader({ redis, streamKey: "test:stream", cache: makeCache(), logger: { debug() {}, info() {}, warn() {}, error() {} } })
+
+        const errors: Error[] = []
+        // 1 回目の購読 → createClient throw → error emit → _state idle へ復帰
+        const unsub1 = reader.subscribe(
+            () => {},
+            (e) => errors.push(e),
+        )
+        // マイクロタスク/ループ完了を待つ
+        await vi.waitFor(() => expect(errors.length).toBeGreaterThanOrEqual(1))
+        expect(errors[0].message).toBe("connection refused")
+        unsub1()
+
+        // 2 回目の購読 → createClient は再度呼ばれる (state-stuck していない証拠)
+        const unsub2 = reader.subscribe(
+            () => {},
+            () => {},
+        )
+        await vi.waitFor(() => expect(attempts).toBe(2))
+        unsub2()
+        await reader.destroy()
+    })
+})

package/src/server/sse-reader.ts

@@ -0,0 +1,223 @@
+/**
+ * Fan-Out shared reader for the daily report SSE Redis Stream.
+ * 日報 SSE 用 Redis Stream の共有リーダーモジュール。
+ *
+ * 単一の xRead BLOCK ループで全接続にメッセージをブロードキャストし、
+ * 接続ごとに Redis TCP を張る問題を解消する。
+ */
+
+import { EventEmitter } from "node:events"
+import { createLogger, type DailyReportLogger, LogLevel } from "../shared/logger"
+import type { SqlResultCache } from "./cache"
+import type { DailyReportRedisBlockingClient, DailyReportRedisProvider } from "./ports"
+
+/**
+ * Compares two Redis Stream IDs numerically.
+ * Redis Stream ID を数値比較し、a <= b なら true を返す。
+ *
+ * Stream ID は `<timestamp_ms>-<sequence>` 形式。
+ * 辞書順比較では sequence が可変長のとき不正確になるため、数値分割で比較する。
+ */
+export const isStreamIdLte = (a: string, b: string): boolean => {
+    const [aMs, aSeq] = a.split("-").map(Number)
+    const [bMs, bSeq] = b.split("-").map(Number)
+    if (aMs !== bMs) return aMs < bMs
+    return aSeq <= bSeq
+}
+
+/** xRead 結果の 1 エントリに相当する型。 */
+export type StreamEntry = {
+    id: string
+    message: Record<string, string>
+}
+
+export type DailyReportSseReaderConfig = {
+    /** ブロッキング xRead 用の専用クライアントを生成する redis プロバイダー。 */
+    redis?: DailyReportRedisProvider
+    /** SSE Redis Stream キー。 */
+    streamKey: string
+    /** 受信メッセージに応じてローカル SQL キャッシュを無効化する対象キャッシュ。 */
+    cache: SqlResultCache
+    /** ロガー (既定は console ベース)。 */
+    logger?: DailyReportLogger
+}
+
+/**
+ * Shared xRead loop that fans out entries to all active SSE connections.
+ * 全 SSE 接続に対してメッセージをファンアウトする共有 xRead ループ。
+ *
+ * - "entry" イベント: 新着エントリ (StreamEntry) をブロードキャスト
+ * - "error" イベント: 回復不能エラーをブロードキャスト
+ * */
+export class DailyReportSseReader {
+    private _emitter = new EventEmitter()
+    private _state: "idle" | "running" | "stopping" = "idle"
+    private _refCount = 0
+    private _lastId = "0-0"
+    private _client: DailyReportRedisBlockingClient | undefined
+    private readonly _logger: DailyReportLogger
+
+    constructor(private readonly config: DailyReportSseReaderConfig) {
+        // リスナー上限を緩和 (接続数分)
+        this._emitter.setMaxListeners(0)
+        this._logger = config.logger ?? createLogger(LogLevel.INFO, "[SSE Reader]")
+    }
+
+    /**
+     * Subscribes to the shared reader. Starts the loop on first subscriber.
+     * 共有リーダーを購読する。最初の購読者でループを開始する。
+     *
+     * @param onEntry - 新着エントリのコールバック
+     * @param onError - 回復不能エラーのコールバック (省略可)
+     * @returns unsubscribe 関数。呼び出すと両リスナーを解除し、最後の購読者解除でループを停止する。
+     */
+    subscribe(onEntry: (entry: StreamEntry) => void, onError?: (err: Error) => void): () => void {
+        this._emitter.on("entry", onEntry)
+        if (onError) {
+            this._emitter.on("error", onError)
+        }
+        this._refCount++
+
+        // 最初の購読者でループ開始
+        if (this._refCount === 1) {
+            void this._startLoop()
+        }
+
+        // unsubscribe
+        return () => {
+            this._emitter.removeListener("entry", onEntry)
+            if (onError) {
+                this._emitter.removeListener("error", onError)
+            }
+            this._refCount--
+            if (this._refCount <= 0) {
+                this._refCount = 0
+                void this._stopLoop()
+            }
+        }
+    }
+
+    /**
+     * Destroys the reader for test cleanup.
+     * テストクリーンアップ用のデストラクタ。
+     */
+    async destroy(): Promise<void> {
+        this._refCount = 0
+        await this._stopLoop()
+        this._emitter.removeAllListeners()
+        this._lastId = "0-0"
+    }
+
+    /**
+     * Internal xRead BLOCK loop.
+     * 内部 xRead BLOCK ループ。
+     */
+    private async _startLoop(): Promise<void> {
+        // stopping 中なら完了を待つ
+        while (this._state === "stopping") {
+            await new Promise((resolve) => setTimeout(resolve, 50))
+        }
+        if (this._state === "running") return
+
+        this._state = "running"
+
+        // 専用クライアント取得。createClient が reject した場合も _state を idle へ戻し、
+        // 再購読でループを再開できるようにする (注入 redis 実装が例外を投げても state-stuck しない)。
+        try {
+            this._client = await this.config.redis?.createClient()
+        } catch (err) {
+            this._state = "idle"
+            this._emitter.emit("error", err instanceof Error ? err : new Error("Failed to create Redis client for SSE reader"))
+            return
+        }
+        if (!this._client) {
+            this._state = "idle"
+            this._emitter.emit("error", new Error("Failed to create Redis client for SSE reader"))
+            return
+        }
+
+        // エラーリスナー
+        this._client.on("error", (err) => {
+            this._logger.error("Redis client error:", err)
+        })
+
+        try {
+            while (this._state === "running" && this._client?.isOpen) {
+                const results = await this._client.xRead([{ key: this.config.streamKey, id: this._lastId }], { BLOCK: 5000, COUNT: 100 })
+                if (!results) continue
+
+                for (const stream of results) {
+                    for (const msg of stream.messages) {
+                        this._lastId = msg.id
+                        // epoch check の補完: SSE 経由でもローカルキャッシュを即座にクリア
+                        // (epoch check が主防御線。SSE は Redis ダウン時や非 epoch 対象キャッシュへのフォールバック)
+                        try {
+                            const parsed = msg.message?.data ? JSON.parse(msg.message.data) : null
+                            const msgType = parsed?.type
+                            if (msgType === "report-create" || msgType === "report-delete" || msgType === "report-publish") {
+                                this.config.cache.invalidatePrefix("daily-report:ids")
+                            }
+                            // コメント・ステータス変更時は対象レポートの詳細キャッシュを無効化
+                            if (msgType === "comment-add" || msgType === "comment-delete" || msgType === "status-update") {
+                                const reportHubId = parsed?.reportHubId
+                                if (typeof reportHubId === "number") {
+                                    this.config.cache.invalidate(`daily-report:detail:${reportHubId}`)
+                                    this.config.cache.invalidatePrefix(`daily-report:detail:${reportHubId}:user:`)
+                                }
+                            }
+                        } catch {
+                            // JSON パースエラーは無視 (invalidation スキップ = safe 方向)
+                        }
+                        this._emitter.emit("entry", { id: msg.id, message: msg.message as Record<string, string> })
+                    }
+                }
+            }
+        } catch (err) {
+            // ClientClosedError は正常停止時に発生する
+            const isClientClosed = (err as Error)?.constructor?.name === "ClientClosedError"
+            if (!isClientClosed && this._state === "running") {
+                this._logger.error("xRead loop error:", err)
+                this._emitter.emit("error", err)
+            }
+        } finally {
+            // クライアント切断
+            if (this._client?.isOpen) {
+                try {
+                    await this._client.quit()
+                } catch (_e) {
+                    // 切断エラーは無視
+                }
+            }
+            this._client = undefined
+            this._state = "idle"
+
+            // ループ終了後に購読者が残っていれば自動再起動
+            if (this._refCount > 0) {
+                void this._startLoop()
+            }
+        }
+    }
+
+    /**
+     * Stops the xRead loop by closing the client.
+     * クライアントを閉じて xRead ループを停止する。
+     */
+    private async _stopLoop(): Promise<void> {
+        if (this._state !== "running") return
+        this._state = "stopping"
+
+        if (this._client?.isOpen) {
+            try {
+                await this._client.quit()
+            } catch (_e) {
+                // 切断エラーは無視
+            }
+        }
+
+        // idle になるまで待機。_state は別の非同期ループ (connect の run ループ) が "idle" に戻すが、
+        // TS は await を跨いだクラスフィールドの変化を追えず "stopping" に過剰 narrowing するため、宣言型へキャストして比較する。
+        while ((this._state as "idle" | "running" | "stopping") !== "idle") {
+            await new Promise((resolve) => setTimeout(resolve, 50))
+        }
+    }
+}

package/src/server.ts

@@ -0,0 +1,83 @@
+/**
+ * Server entry of @aiquants/daily-report: schema factory, service, SSE reader, and handler factories.
+ * @aiquants/daily-report の server エントリ。スキーマファクトリ・サービス・SSE リーダー・ハンドラ工場を公開。
+ */
+import { createEpochStore, SqlResultCache } from "./server/cache"
+import type { DailyReportExternalSource } from "./server/external-source"
+import { createDailyReportHandlers } from "./server/handlers"
+import type { DailyReportAuthenticate } from "./server/ports"
+import { createDailyReportService, type DailyReportServiceConfig } from "./server/service"
+import { DailyReportSseReader } from "./server/sse-reader"
+
+export * from "./server/cache"
+export { generateETag } from "./server/etag"
+export * from "./server/external-source"
+export * from "./server/handlers"
+export * from "./server/ports"
+export * from "./server/response"
+export * from "./server/schema"
+export * from "./server/service"
+export * from "./server/sse-reader"
+
+/** createDailyReportServer の設定 (サービス設定 + 認証ポート + ハンドラ設定)。 */
+export type DailyReportServerConfig = Omit<DailyReportServiceConfig, "cache" | "epochs"> & {
+    /** リクエスト認証ポート。 */
+    authenticate: DailyReportAuthenticate
+    /** 未ログイン時のリダイレクト先 (index.loader 用、既定 "/auth/login")。 */
+    loginRedirectPath?: string
+    /** SQL 結果キャッシュの既定 TTL (既定 60,000ms)。 */
+    cacheDefaultTtlMs?: number
+    /** 外部ソースアダプタ群 (レガシー日報テーブル等)。 */
+    externalSources?: DailyReportExternalSource[]
+}
+
+/**
+ * One-stop factory wiring cache, service, SSE fan-out reader, and route handlers.
+ * キャッシュ・サービス・SSE Fan-Out リーダー・ルートハンドラを一括結線するファクトリ。
+ *
+ * @example
+ * const server = createDailyReportServer({ db, tables, userTable, resolveUserId, encodeUserId, authenticate, redis })
+ * // routes:
+ * //   daily_report._index      → server.index.loader (+ data() ラップ)
+ * //   daily_report.api.$endpoint → server.api.loader / server.api.action
+ * //   sse.daily_report.$endpoint → server.sse.loader
+ */
+export function createDailyReportServer(config: DailyReportServerConfig) {
+    // epoch ストアと SQL 結果キャッシュ (サービスと SSE リーダーで同一インスタンスを共有する)
+    const epochs = createEpochStore(config.redis)
+    const cache = new SqlResultCache({ defaultTtlMs: config.cacheDefaultTtlMs ?? 60_000 }, epochs)
+
+    const service = createDailyReportService({ ...config, cache, epochs })
+
+    const sseReader = new DailyReportSseReader({
+        redis: config.redis,
+        streamKey: service.streamKey,
+        cache,
+        logger: config.logger,
+    })
+
+    const handlers = createDailyReportHandlers({
+        authenticate: config.authenticate,
+        service,
+        encodeUserId: config.encodeUserId,
+        redis: config.redis,
+        sseReader,
+        streamKey: service.streamKey,
+        loginRedirectPath: config.loginRedirectPath,
+        logger: config.logger,
+    })
+
+    return {
+        /** データアクセスサービス (CRUD + キャッシュ + SSE publish)。 */
+        service,
+        /** SQL 結果キャッシュ (サービス・SSE リーダー共有インスタンス)。 */
+        cache,
+        /** クロスワーカー epoch ストア。 */
+        epochs,
+        /** SSE Fan-Out 共有リーダー。 */
+        sseReader,
+        /** SSE Redis Stream キー。 */
+        streamKey: service.streamKey,
+        ...handlers,
+    }
+}

package/src/shared/business-date.spec.ts

@@ -0,0 +1,61 @@
+import { describe, expect, it } from "vitest"
+import { formatBusinessDateDisplay, normalizeBusinessDateKey, parseBusinessDateKeyToDate } from "./business-date"
+
+describe("business-date utils", () => {
+    describe("normalizeBusinessDateKey", () => {
+        it("should normalize Date object", () => {
+            const date = new Date(2023, 0, 1) // 2023-01-01
+            expect(normalizeBusinessDateKey(date)).toBe("2023-01-01")
+        })
+
+        it("should normalize ISO string", () => {
+            expect(normalizeBusinessDateKey("2023-01-01")).toBe("2023-01-01")
+        })
+
+        it("should normalize slash string", () => {
+            expect(normalizeBusinessDateKey("2023/01/01")).toBe("2023-01-01")
+        })
+
+        it("should normalize other date strings", () => {
+            expect(normalizeBusinessDateKey("Jan 1, 2023")).toBe("2023-01-01")
+        })
+
+        it("should return null for null/undefined", () => {
+            expect(normalizeBusinessDateKey(null)).toBeNull()
+            expect(normalizeBusinessDateKey(undefined)).toBeNull()
+        })
+
+        it("should return null for empty string", () => {
+            expect(normalizeBusinessDateKey("")).toBeNull()
+            expect(normalizeBusinessDateKey("   ")).toBeNull()
+        })
+
+        it("should return null for invalid date string", () => {
+            expect(normalizeBusinessDateKey("invalid-date")).toBeNull()
+        })
+    })
+
+    describe("formatBusinessDateDisplay", () => {
+        it("should format valid input", () => {
+            expect(formatBusinessDateDisplay("2023/01/01")).toBe("2023-01-01")
+        })
+
+        it("should return null for invalid input", () => {
+            expect(formatBusinessDateDisplay("invalid")).toBeNull()
+        })
+    })
+
+    describe("parseBusinessDateKeyToDate", () => {
+        it("should parse valid input", () => {
+            const result = parseBusinessDateKeyToDate("2023-01-01")
+            expect(result).toBeInstanceOf(Date)
+            expect(result?.getFullYear()).toBe(2023)
+            expect(result?.getMonth()).toBe(0)
+            expect(result?.getDate()).toBe(1)
+        })
+
+        it("should return null for invalid input", () => {
+            expect(parseBusinessDateKeyToDate("invalid")).toBeNull()
+        })
+    })
+})

package/src/shared/business-date.ts

@@ -0,0 +1,84 @@
+/**
+ * Business date normalization and formatting helper functions.
+ * 営業日の正規化とフォーマットを支援するユーティリティ群。
+ */
+
+type BusinessDateInput = string | Date | null | undefined
+
+const ISO_DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/
+const SLASH_DATE_PATTERN = /^\d{4}\/\d{2}\/\d{2}$/
+
+const zeroPad = (value: number): string => {
+    return value < 10 ? `0${value}` : `${value}`
+}
+
+const normalizeFromDate = (value: Date): string | null => {
+    if (Number.isNaN(value.getTime())) {
+        return null
+    }
+
+    const year = value.getFullYear()
+    const month = zeroPad(value.getMonth() + 1)
+    const day = zeroPad(value.getDate())
+    return `${year}-${month}-${day}`
+}
+
+/**
+ * Normalizes business date input into YYYY-MM-DD format string.
+ * 営業日を YYYY-MM-DD 形式の文字列へ正規化する。
+ */
+export const normalizeBusinessDateKey = (value: BusinessDateInput): string | null => {
+    if (value === null || value === undefined) {
+        return null
+    }
+
+    if (value instanceof Date) {
+        return normalizeFromDate(value)
+    }
+
+    const trimmed = value.trim()
+    if (trimmed === "") {
+        return null
+    }
+
+    if (ISO_DATE_PATTERN.test(trimmed)) {
+        return trimmed
+    }
+
+    if (SLASH_DATE_PATTERN.test(trimmed)) {
+        return trimmed.replaceAll("/", "-")
+    }
+
+    const parsed = new Date(trimmed)
+    return normalizeFromDate(parsed)
+}
+
+/**
+ * Converts normalized business date into display format YYYY-MM-DD.
+ * 正規化済みの営業日を YYYY-MM-DD 形式の表示文字列へ変換する。
+ */
+export const formatBusinessDateDisplay = (value: BusinessDateInput): string | null => {
+    const normalized = normalizeBusinessDateKey(value)
+    if (!normalized) {
+        return null
+    }
+    return normalized
+}
+
+/**
+ * Parses normalized business date into Date object.
+ * 正規化した営業日を Date オブジェクトへ変換する。
+ */
+export const parseBusinessDateKeyToDate = (value: BusinessDateInput): Date | null => {
+    const normalized = normalizeBusinessDateKey(value)
+    if (!normalized) {
+        return null
+    }
+
+    const [year, month, day] = normalized.split("-").map((part) => Number.parseInt(part, 10))
+    if ([year, month, day].some((component) => Number.isNaN(component))) {
+        return null
+    }
+
+    return new Date(year, month - 1, day)
+}

package/src/shared/comment-adapter.ts

@@ -0,0 +1,78 @@
+/**
+ * Adapters merging legacy JSON comments and relational comments for the UI.
+ * レガシー JSON コメントとリレーショナルコメントを UI 向けに統合するアダプタ群。
+ */
+import type { DailyReportComment, DailyReportCommentItem } from "./types"
+
+export type UIComment = {
+    id: string | number
+    authorName: string
+    content: string
+    createdAt?: string
+    isMine: boolean
+    color?: string
+    isLegacy: boolean
+}
+
+/**
+ * Merges legacy JSON comments and modern relational comments into a unified UI format.
+ * レガシーな JSON コメントとモダンなリレーショナルコメントを統合された UI 形式にマージする。
+ */
+export const mergeComments = (legacyComments: DailyReportComment[], modernComments: DailyReportCommentItem[], currentUserId?: string | null): UIComment[] => {
+    // 1. Legacy コメントの変換
+    const legacyUIComments: UIComment[] = legacyComments.map((c, index) => ({
+        id: `legacy-${index}`,
+        authorName: c.name || "Unknown",
+        content: c.text || "",
+        isMine: false,
+        color: c.color || undefined,
+        isLegacy: true,
+    }))
+
+    // 2. Modern コメントの変換
+    const modernUIComments: UIComment[] = modernComments.map((c) => ({
+        id: c.id,
+        authorName: c.userName,
+        content: c.content,
+        createdAt: c.createdAt,
+        isMine: currentUserId ? c.userId === currentUserId : c.isMine,
+        isLegacy: false,
+    }))
+
+    // 3. 結合 (Legacy を先に表示)
+    return [...legacyUIComments, ...modernUIComments]
+}
+
+/**
+ * Resolves comment color tokens into Tailwind text classes.
+ * コメント色のキーワードを Tailwind のテキストクラスに変換する関数。
+ */
+export const resolveCommentColorClass = (color: string | null | undefined): string => {
+    if (!color) {
+        return "text-gray-700"
+    }
+
+    const normalized = color.toLowerCase()
+
+    if (normalized.includes("red") || normalized.includes("赤")) {
+        return "text-red-600"
+    }
+
+    if (normalized.includes("green") || normalized.includes("緑")) {
+        return "text-green-600"
+    }
+
+    if (normalized.includes("blue") || normalized.includes("青")) {
+        return "text-blue-600"
+    }
+
+    if (normalized.includes("yellow") || normalized.includes("黄")) {
+        return "text-yellow-600"
+    }
+
+    if (normalized.includes("orange") || normalized.includes("橙")) {
+        return "text-orange-500"
+    }
+
+    return "text-gray-700"
+}

package/src/shared/logger.ts

@@ -0,0 +1,47 @@
+/**
+ * Minimal level-filtered logger used internally by the daily-report package.
+ * daily-report パッケージ内部で使う最小のレベルフィルタ付きロガー。
+ *
+ * 消費アプリのロガー実装 (console 互換の debug/info/warn/error) を注入でき、
+ * 未注入時は console にフォールバックする。
+ */
+
+/** 出力フィルタリング用のログレベル。 */
+export enum LogLevel {
+    DEBUG = 0,
+    INFO = 1,
+    WARN = 2,
+    ERROR = 3,
+    NONE = 4,
+}
+
+/** Console 互換のロガーインターフェース。 */
+export interface DailyReportLogger {
+    debug(message?: unknown, ...optionalParams: unknown[]): void
+    info(message?: unknown, ...optionalParams: unknown[]): void
+    warn(message?: unknown, ...optionalParams: unknown[]): void
+    error(message?: unknown, ...optionalParams: unknown[]): void
+}
+
+/**
+ * Creates a prefixed, level-filtered logger delegating to the given implementation.
+ * 指定実装へ委譲するプレフィックス付き・レベルフィルタ付きロガーを生成する処理。
+ */
+export const createLogger = (level: LogLevel, prefix: string, impl: DailyReportLogger = console): DailyReportLogger => {
+    // 文字列メッセージはプレフィックスを連結、それ以外は先頭引数として付加する
+    const format = (message: unknown): unknown[] => (typeof message === "string" ? [`${prefix} ${message}`] : [prefix, message])
+    return {
+        debug: (message?: unknown, ...rest: unknown[]) => {
+            if (level <= LogLevel.DEBUG) impl.debug(...format(message), ...rest)
+        },
+        info: (message?: unknown, ...rest: unknown[]) => {
+            if (level <= LogLevel.INFO) impl.info(...format(message), ...rest)
+        },
+        warn: (message?: unknown, ...rest: unknown[]) => {
+            if (level <= LogLevel.WARN) impl.warn(...format(message), ...rest)
+        },
+        error: (message?: unknown, ...rest: unknown[]) => {
+            if (level <= LogLevel.ERROR) impl.error(...format(message), ...rest)
+        },
+    }
+}