// server/trpc.ts -- tRPC の初期化
import { initTRPC, TRPCError } from "@trpc/server";
import { z } from "zod";
 
// コンテキスト型
interface Context {
  userId: string | null;
  db: PrismaClient;
}
 
const t = initTRPC.context<Context>().create({
  errorFormatter({ shape, error }) {
    return {
      ...shape,
      data: {
        ...shape.data,
        zodError:
          error.cause instanceof z.ZodError
            ? error.cause.flatten()
            : null,
      },
    };
  },
});
 
// エクスポート
export const router = t.router;
export const publicProcedure = t.procedure;
export const middleware = t.middleware;

// server/routers/user.ts
import { z } from "zod";
import { router, publicProcedure } from "../trpc";
 
const UserCreateInput = z.object({
  name: z.string().min(1).max(100),
  email: z.string().email(),
  age: z.number().int().min(0).optional(),
});
 
const UserUpdateInput = z.object({
  name: z.string().min(1).max(100).optional(),
  email: z.string().email().optional(),
});
 
export const userRouter = router({
  // Query: データ取得
  list: publicProcedure
    .input(
      z.object({
        page: z.number().int().min(1).default(1),
        limit: z.number().int().min(1).max(100).default(20),
      })
    )
    .query(async ({ ctx, input }) => {
      const users = await ctx.db.user.findMany({
        skip: (input.page - 1) * input.limit,
        take: input.limit,
        orderBy: { createdAt: "desc" },
      });
      const total = await ctx.db.user.count();
      return { users, total, page: input.page };
    }),
 
  // Query: 単一取得
  byId: publicProcedure
    .input(z.object({ id: z.string().uuid() }))
    .query(async ({ ctx, input }) => {
      const user = await ctx.db.user.findUnique({
        where: { id: input.id },
        include: { profile: true },
      });
      if (!user) {
        throw new TRPCError({
          code: "NOT_FOUND",
          message: `User ${input.id} not found`,
        });
      }
      return user;
    }),
 
  // Mutation: 作成
  create: publicProcedure
    .input(UserCreateInput)
    .mutation(async ({ ctx, input }) => {
      return ctx.db.user.create({ data: input });
    }),
 
  // Mutation: 更新
  update: publicProcedure
    .input(
      z.object({
        id: z.string().uuid(),
        data: UserUpdateInput,
      })
    )
    .mutation(async ({ ctx, input }) => {
      return ctx.db.user.update({
        where: { id: input.id },
        data: input.data,
      });
    }),
 
  // Mutation: 削除
  delete: publicProcedure
    .input(z.object({ id: z.string().uuid() }))
    .mutation(async ({ ctx, input }) => {
      await ctx.db.user.delete({ where: { id: input.id } });
      return { success: true };
    }),
});

// server/routers/_app.ts
import { router } from "../trpc";
import { userRouter } from "./user";
import { postRouter } from "./post";
 
export const appRouter = router({
  user: userRouter,
  post: postRouter,
});
 
// 型をエクスポート（クライアントで使用）
export type AppRouter = typeof appRouter;

// server/context.ts -- 高度なコンテキスト生成
import { inferAsyncReturnType } from "@trpc/server";
import { CreateNextContextOptions } from "@trpc/server/adapters/next";
import { getServerSession } from "next-auth";
import { authOptions } from "../auth";
import { prisma } from "../db";
 
/**
 * コンテキスト生成関数
 * リクエストごとに呼ばれ、全プロシージャから参照可能な共有状態を作る
 */
export async function createContext(opts: CreateNextContextOptions) {
  const session = await getServerSession(opts.req, opts.res, authOptions);
 
  return {
    session,
    userId: session?.user?.id ?? null,
    db: prisma,
    req: opts.req,
    res: opts.res,
  };
}
 
export type Context = inferAsyncReturnType<typeof createContext>;

// server/context.ts -- Fetch API 用（App Router / Edge Runtime）
import { FetchCreateContextFnOptions } from "@trpc/server/adapters/fetch";
import { getToken } from "next-auth/jwt";
 
export async function createContext(opts: FetchCreateContextFnOptions) {
  // ヘッダーからトークンを取得
  const authHeader = opts.req.headers.get("authorization");
  const token = authHeader?.replace("Bearer ", "");
 
  let userId: string | null = null;
  if (token) {
    try {
      const decoded = await verifyJWT(token);
      userId = decoded.sub;
    } catch {
      // トークン無効 -- userId は null のまま
    }
  }
 
  return {
    userId,
    db: prisma,
    requestId: crypto.randomUUID(),
    ip: opts.req.headers.get("x-forwarded-for") ?? "unknown",
  };
}

// server/schemas/user.ts -- 再利用可能なスキーマ
import { z } from "zod";
 
// 基本スキーマ
export const UserSchema = z.object({
  id: z.string().uuid(),
  name: z.string().min(1).max(100),
  email: z.string().email(),
  role: z.enum(["USER", "ADMIN", "MODERATOR"]),
  createdAt: z.date(),
  updatedAt: z.date(),
});
 
// 部分型（PATCH 更新用）
export const UserUpdateSchema = UserSchema.pick({
  name: true,
  email: true,
  role: true,
}).partial();
 
// 作成用（id, timestamps を除外）
export const UserCreateSchema = UserSchema.omit({
  id: true,
  createdAt: true,
  updatedAt: true,
});
 
// フィルター用
export const UserFilterSchema = z.object({
  search: z.string().optional(),
  role: z.enum(["USER", "ADMIN", "MODERATOR"]).optional(),
  createdAfter: z.date().optional(),
  createdBefore: z.date().optional(),
});
 
// ページネーション用（汎用）
export const PaginationSchema = z.object({
  page: z.number().int().min(1).default(1),
  limit: z.number().int().min(1).max(100).default(20),
  sortBy: z.string().optional(),
  sortOrder: z.enum(["asc", "desc"]).default("desc"),
});
 
// 組み合わせ
export const UserListInput = PaginationSchema.merge(UserFilterSchema);
 
// 型の抽出（他のファイルで使用可能）
export type UserCreate = z.infer<typeof UserCreateSchema>;
export type UserUpdate = z.infer<typeof UserUpdateSchema>;
export type UserFilter = z.infer<typeof UserFilterSchema>;

// server/routers/user.ts -- 外部スキーマを利用したルーター
import { router, publicProcedure, protectedProcedure } from "../trpc";
import {
  UserCreateSchema,
  UserUpdateSchema,
  UserListInput,
} from "../schemas/user";
 
export const userRouter = router({
  list: publicProcedure
    .input(UserListInput)
    .query(async ({ ctx, input }) => {
      const { page, limit, sortBy, sortOrder, search, role } = input;
 
      const where = {
        ...(search && {
          OR: [
            { name: { contains: search, mode: "insensitive" as const } },
            { email: { contains: search, mode: "insensitive" as const } },
          ],
        }),
        ...(role && { role }),
      };
 
      const [users, total] = await Promise.all([
        ctx.db.user.findMany({
          where,
          skip: (page - 1) * limit,
          take: limit,
          orderBy: sortBy ? { [sortBy]: sortOrder } : { createdAt: sortOrder },
        }),
        ctx.db.user.count({ where }),
      ]);
 
      return {
        users,
        total,
        page,
        totalPages: Math.ceil(total / limit),
        hasMore: page * limit < total,
      };
    }),
 
  create: protectedProcedure
    .input(UserCreateSchema)
    .mutation(async ({ ctx, input }) => {
      // メールの重複チェック
      const existing = await ctx.db.user.findUnique({
        where: { email: input.email },
      });
      if (existing) {
        throw new TRPCError({
          code: "CONFLICT",
          message: "A user with this email already exists",
        });
      }
      return ctx.db.user.create({ data: input });
    }),
});

// 認証ミドルウェア
const isAuthed = middleware(async ({ ctx, next }) => {
  if (!ctx.userId) {
    throw new TRPCError({
      code: "UNAUTHORIZED",
      message: "You must be logged in",
    });
  }
 
  const user = await ctx.db.user.findUnique({
    where: { id: ctx.userId },
  });
 
  if (!user) {
    throw new TRPCError({
      code: "UNAUTHORIZED",
      message: "User not found",
    });
  }
 
  return next({
    ctx: {
      ...ctx,
      userId: ctx.userId, // string (non-null が保証)
      user,               // User 型が ctx に追加
    },
  });
});
 
// 管理者ミドルウェア
const isAdmin = middleware(async ({ ctx, next }) => {
  // isAuthed の後に使用する前提
  if ((ctx as any).user?.role !== "ADMIN") {
    throw new TRPCError({
      code: "FORBIDDEN",
      message: "Admin access required",
    });
  }
  return next({ ctx });
});
 
// プロシージャのベース
const protectedProcedure = publicProcedure.use(isAuthed);
const adminProcedure = protectedProcedure.use(isAdmin);
 
// 使用例
export const adminRouter = router({
  listAllUsers: adminProcedure.query(async ({ ctx }) => {
    // ctx.user は User 型で保証されている
    return ctx.db.user.findMany();
  }),
});

// server/middleware/logging.ts
import { middleware } from "../trpc";
 
/**
 * リクエストのタイミングとパスをログ出力するミドルウェア
 */
export const loggerMiddleware = middleware(async ({ path, type, next }) => {
  const start = Date.now();
 
  const result = await next();
 
  const durationMs = Date.now() - start;
  const meta = {
    path,
    type,         // "query" | "mutation" | "subscription"
    durationMs,
    ok: result.ok,
  };
 
  if (result.ok) {
    console.log(`[tRPC] ${type} ${path} - ${durationMs}ms OK`);
  } else {
    console.error(`[tRPC] ${type} ${path} - ${durationMs}ms ERROR`, meta);
  }
 
  return result;
});
 
// 全プロシージャに適用
export const publicProcedure = t.procedure.use(loggerMiddleware);

// server/middleware/rateLimit.ts
import { middleware } from "../trpc";
import { TRPCError } from "@trpc/server";
 
// シンプルなインメモリレート制限（本番では Redis を使用）
const rateLimitMap = new Map<string, { count: number; resetAt: number }>();
 
interface RateLimitOptions {
  windowMs: number;  // ウィンドウ時間（ミリ秒）
  maxRequests: number;  // ウィンドウ内の最大リクエスト数
}
 
export function createRateLimitMiddleware(options: RateLimitOptions) {
  return middleware(async ({ ctx, next }) => {
    const key = ctx.userId ?? ctx.ip ?? "anonymous";
    const now = Date.now();
 
    let record = rateLimitMap.get(key);
 
    if (!record || now > record.resetAt) {
      record = { count: 0, resetAt: now + options.windowMs };
      rateLimitMap.set(key, record);
    }
 
    record.count++;
 
    if (record.count > options.maxRequests) {
      throw new TRPCError({
        code: "TOO_MANY_REQUESTS",
        message: `Rate limit exceeded. Try again in ${Math.ceil(
          (record.resetAt - now) / 1000
        )} seconds`,
      });
    }
 
    return next();
  });
}
 
// 使用例
const rateLimitedProcedure = publicProcedure.use(
  createRateLimitMiddleware({
    windowMs: 60_000,   // 1分間
    maxRequests: 100,    // 最大100リクエスト
  })
);
 
// Redis ベースのレート制限（本番推奨）
import { Redis } from "ioredis";
 
const redis = new Redis(process.env.REDIS_URL!);
 
export function createRedisRateLimitMiddleware(options: RateLimitOptions) {
  return middleware(async ({ ctx, next }) => {
    const key = `ratelimit:${ctx.userId ?? ctx.ip ?? "anon"}`;
    const current = await redis.incr(key);
 
    if (current === 1) {
      await redis.pexpire(key, options.windowMs);
    }
 
    if (current > options.maxRequests) {
      const ttl = await redis.pttl(key);
      throw new TRPCError({
        code: "TOO_MANY_REQUESTS",
        message: `Rate limit exceeded. Try again in ${Math.ceil(ttl / 1000)}s`,
      });
    }
 
    return next();
  });
}

// server/middleware/organization.ts
import { middleware } from "../trpc";
import { TRPCError } from "@trpc/server";
import { z } from "zod";
 
/**
 * 組織メンバーシップを検証するミドルウェア
 * protectedProcedure の後に使用する
 */
export const withOrganization = middleware(async ({ ctx, next, rawInput }) => {
  // rawInput から orgId を取得
  const parsed = z.object({ orgId: z.string() }).safeParse(rawInput);
  if (!parsed.success) {
    throw new TRPCError({
      code: "BAD_REQUEST",
      message: "Organization ID is required",
    });
  }
 
  const membership = await ctx.db.organizationMember.findUnique({
    where: {
      userId_organizationId: {
        userId: ctx.userId,
        organizationId: parsed.data.orgId,
      },
    },
    include: { organization: true },
  });
 
  if (!membership) {
    throw new TRPCError({
      code: "FORBIDDEN",
      message: "You are not a member of this organization",
    });
  }
 
  return next({
    ctx: {
      ...ctx,
      organization: membership.organization,
      memberRole: membership.role, // "OWNER" | "ADMIN" | "MEMBER"
    },
  });
});
 
// 組織管理者専用
export const withOrgAdmin = middleware(async ({ ctx, next }) => {
  if (!["OWNER", "ADMIN"].includes((ctx as any).memberRole)) {
    throw new TRPCError({
      code: "FORBIDDEN",
      message: "Organization admin access required",
    });
  }
  return next({ ctx });
});
 
// プロシージャ定義
const orgProcedure = protectedProcedure.use(withOrganization);
const orgAdminProcedure = orgProcedure.use(withOrgAdmin);
 
// 使用例
export const orgRouter = router({
  getMembers: orgProcedure
    .input(z.object({ orgId: z.string() }))
    .query(async ({ ctx }) => {
      return ctx.db.organizationMember.findMany({
        where: { organizationId: ctx.organization.id },
        include: { user: true },
      });
    }),
 
  removeMember: orgAdminProcedure
    .input(z.object({
      orgId: z.string(),
      memberId: z.string(),
    }))
    .mutation(async ({ ctx, input }) => {
      // OWNER は削除不可
      const target = await ctx.db.organizationMember.findUnique({
        where: {
          userId_organizationId: {
            userId: input.memberId,
            organizationId: ctx.organization.id,
          },
        },
      });
 
      if (target?.role === "OWNER") {
        throw new TRPCError({
          code: "FORBIDDEN",
          message: "Cannot remove the organization owner",
        });
      }
 
      await ctx.db.organizationMember.delete({
        where: {
          userId_organizationId: {
            userId: input.memberId,
            organizationId: ctx.organization.id,
          },
        },
      });
 
      return { success: true };
    }),
});

// utils/trpc.ts
import { createTRPCReact } from "@trpc/react-query";
import type { AppRouter } from "../server/routers/_app";
 
export const trpc = createTRPCReact<AppRouter>();

// app/providers.tsx
import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
import { httpBatchLink } from "@trpc/client";
import { trpc } from "../utils/trpc";
 
const queryClient = new QueryClient();
const trpcClient = trpc.createClient({
  links: [
    httpBatchLink({
      url: "http://localhost:3000/api/trpc",
      headers: () => ({
        Authorization: `Bearer ${getToken()}`,
      }),
    }),
  ],
});
 
export function Providers({ children }: { children: React.ReactNode }) {
  return (
    <trpc.Provider client={trpcClient} queryClient={queryClient}>
      <QueryClientProvider client={queryClient}>
        {children}
      </QueryClientProvider>
    </trpc.Provider>
  );
}

// components/UserList.tsx
import { trpc } from "../utils/trpc";
 
export function UserList() {
  // Query: 型が自動推論される
  const { data, isLoading, error } = trpc.user.list.useQuery({
    page: 1,
    limit: 20,
  });
  // data の型: { users: User[]; total: number; page: number } | undefined
 
  // Mutation
  const createUser = trpc.user.create.useMutation({
    onSuccess: () => {
      // キャッシュを無効化して再取得
      utils.user.list.invalidate();
    },
  });
 
  const utils = trpc.useUtils();
 
  if (isLoading) return <div>Loading...</div>;
  if (error) return <div>Error: {error.message}</div>;
 
  return (
    <div>
      {data.users.map((user) => (
        <div key={user.id}>
          {user.name} ({user.email})
        </div>
      ))}
      <button
        onClick={() =>
          createUser.mutate({
            name: "New User",
            email: "new@example.com",
          })
        }
      >
        Add User
      </button>
    </div>
  );
}

// app/api/trpc/[trpc]/route.ts
import { fetchRequestHandler } from "@trpc/server/adapters/fetch";
import { appRouter } from "../../../../server/routers/_app";
 
const handler = (req: Request) =>
  fetchRequestHandler({
    endpoint: "/api/trpc",
    req,
    router: appRouter,
    createContext: async () => {
      // リクエストからコンテキストを作成
      const userId = await getUserIdFromRequest(req);
      return { userId, db: prisma };
    },
  });
 
export { handler as GET, handler as POST };

// Server Components で直接呼び出し
import { appRouter } from "../server/routers/_app";
 
// サーバーサイド caller
const caller = appRouter.createCaller({
  userId: null,
  db: prisma,
});
 
export default async function UsersPage() {
  // サーバーサイドで直接呼び出し（HTTP 不要）
  const { users } = await caller.user.list({ page: 1, limit: 20 });
 
  return (
    <ul>
      {users.map((user) => (
        <li key={user.id}>{user.name}</li>
      ))}
    </ul>
  );
}

// client/vanilla.ts
import { createTRPCClient, httpBatchLink } from "@trpc/client";
import type { AppRouter } from "../server/routers/_app";
 
// React 不要の純粋な tRPC クライアント
const client = createTRPCClient<AppRouter>({
  links: [
    httpBatchLink({
      url: "http://localhost:3000/api/trpc",
      headers: () => ({
        Authorization: `Bearer ${localStorage.getItem("token")}`,
      }),
    }),
  ],
});
 
// Query の実行
async function fetchUsers() {
  const result = await client.user.list.query({
    page: 1,
    limit: 10,
  });
  // result の型は自動推論される
  console.log(result.users);
  console.log(result.total);
}
 
// Mutation の実行
async function createUser(name: string, email: string) {
  const newUser = await client.user.create.mutate({
    name,
    email,
  });
  // newUser の型もサーバーの戻り値から推論
  console.log(`Created user: ${newUser.id}`);
}
 
// Node.js スクリプトや CLI ツールからの利用
async function main() {
  try {
    await fetchUsers();
    await createUser("Alice", "alice@example.com");
  } catch (err) {
    if (err instanceof TRPCClientError) {
      console.error("tRPC Error:", err.message);
      console.error("Error code:", err.data?.code);
    }
  }
}

// components/TodoList.tsx -- 楽観的更新の完全な例
import { trpc } from "../utils/trpc";
 
export function TodoList() {
  const utils = trpc.useUtils();
 
  const { data: todos } = trpc.todo.list.useQuery();
 
  const toggleTodo = trpc.todo.toggle.useMutation({
    // 楽観的更新: サーバーレスポンスを待たずに UI を更新
    onMutate: async (input) => {
      // 1. 進行中の再取得をキャンセル（楽観的更新を上書きしないため）
      await utils.todo.list.cancel();
 
      // 2. 現在のデータをスナップショット
      const previousTodos = utils.todo.list.getData();
 
      // 3. 楽観的にキャッシュを更新
      utils.todo.list.setData(undefined, (old) => {
        if (!old) return old;
        return old.map((todo) =>
          todo.id === input.id
            ? { ...todo, completed: !todo.completed }
            : todo
        );
      });
 
      // 4. ロールバック用のコンテキストを返す
      return { previousTodos };
    },
 
    // エラー時: スナップショットにロールバック
    onError: (_err, _input, context) => {
      if (context?.previousTodos) {
        utils.todo.list.setData(undefined, context.previousTodos);
      }
    },
 
    // 成功・失敗に関わらず、最終的にサーバーデータと同期
    onSettled: () => {
      utils.todo.list.invalidate();
    },
  });
 
  const deleteTodo = trpc.todo.delete.useMutation({
    onMutate: async (input) => {
      await utils.todo.list.cancel();
      const previousTodos = utils.todo.list.getData();
 
      // 楽観的に削除
      utils.todo.list.setData(undefined, (old) => {
        if (!old) return old;
        return old.filter((todo) => todo.id !== input.id);
      });
 
      return { previousTodos };
    },
    onError: (_err, _input, context) => {
      if (context?.previousTodos) {
        utils.todo.list.setData(undefined, context.previousTodos);
      }
    },
    onSettled: () => {
      utils.todo.list.invalidate();
    },
  });
 
  return (
    <ul>
      {todos?.map((todo) => (
        <li key={todo.id}>
          <label>
            <input
              type="checkbox"
              checked={todo.completed}
              onChange={() => toggleTodo.mutate({ id: todo.id })}
            />
            <span style={{
              textDecoration: todo.completed ? "line-through" : "none",
            }}>
              {todo.title}
            </span>
          </label>
          <button onClick={() => deleteTodo.mutate({ id: todo.id })}>
            Delete
          </button>
        </li>
      ))}
    </ul>
  );
}

// components/InfinitePostList.tsx
import { trpc } from "../utils/trpc";
import { useCallback, useRef, useEffect } from "react";
 
// サーバー側: カーソルベースのページネーション
// server/routers/post.ts
export const postRouter = router({
  infiniteList: publicProcedure
    .input(
      z.object({
        limit: z.number().int().min(1).max(50).default(20),
        cursor: z.string().optional(),  // 最後のアイテムの ID
        category: z.string().optional(),
      })
    )
    .query(async ({ ctx, input }) => {
      const { limit, cursor, category } = input;
 
      const posts = await ctx.db.post.findMany({
        take: limit + 1,  // +1 で次ページの有無を判定
        ...(cursor && {
          cursor: { id: cursor },
          skip: 1,  // カーソル自体はスキップ
        }),
        ...(category && { where: { category } }),
        orderBy: { createdAt: "desc" },
        include: { author: { select: { name: true, avatar: true } } },
      });
 
      let nextCursor: string | undefined;
      if (posts.length > limit) {
        const nextItem = posts.pop();
        nextCursor = nextItem!.id;
      }
 
      return { posts, nextCursor };
    }),
});
 
// クライアント側
export function InfinitePostList() {
  const {
    data,
    fetchNextPage,
    hasNextPage,
    isFetchingNextPage,
    isLoading,
  } = trpc.post.infiniteList.useInfiniteQuery(
    { limit: 20 },
    {
      getNextPageParam: (lastPage) => lastPage.nextCursor,
    }
  );
 
  // Intersection Observer で自動読み込み
  const observerRef = useRef<IntersectionObserver>();
  const loadMoreRef = useCallback(
    (node: HTMLDivElement | null) => {
      if (isFetchingNextPage) return;
      if (observerRef.current) observerRef.current.disconnect();
 
      observerRef.current = new IntersectionObserver((entries) => {
        if (entries[0].isIntersecting && hasNextPage) {
          fetchNextPage();
        }
      });
 
      if (node) observerRef.current.observe(node);
    },
    [isFetchingNextPage, hasNextPage, fetchNextPage]
  );
 
  if (isLoading) return <div>Loading...</div>;
 
  const allPosts = data?.pages.flatMap((page) => page.posts) ?? [];
 
  return (
    <div>
      {allPosts.map((post) => (
        <article key={post.id}>
          <h2>{post.title}</h2>
          <p>by {post.author.name}</p>
          <p>{post.content.slice(0, 200)}...</p>
        </article>
      ))}
 
      <div ref={loadMoreRef}>
        {isFetchingNextPage ? (
          <p>Loading more...</p>
        ) : hasNextPage ? (
          <p>Scroll to load more</p>
        ) : (
          <p>No more posts</p>
        )}
      </div>
    </div>
  );
}

// server/routers/user.test.ts
import { describe, it, expect, vi } from "vitest";
import { appRouter } from "./_app";
 
describe("userRouter", () => {
  const mockDb = {
    user: {
      findMany: vi.fn(),
      findUnique: vi.fn(),
      create: vi.fn(),
      count: vi.fn(),
    },
  } as unknown as PrismaClient;
 
  const caller = appRouter.createCaller({
    userId: "user-1",
    db: mockDb,
  });
 
  it("should list users", async () => {
    const mockUsers = [
      { id: "1", name: "Alice", email: "alice@test.com" },
    ];
    (mockDb.user.findMany as any).mockResolvedValue(mockUsers);
    (mockDb.user.count as any).mockResolvedValue(1);
 
    const result = await caller.user.list({ page: 1, limit: 10 });
 
    expect(result.users).toEqual(mockUsers);
    expect(result.total).toBe(1);
  });
 
  it("should throw NOT_FOUND for invalid id", async () => {
    (mockDb.user.findUnique as any).mockResolvedValue(null);
 
    await expect(
      caller.user.byId({ id: "00000000-0000-0000-0000-000000000000" })
    ).rejects.toThrow("NOT_FOUND");
  });
});

// server/routers/user.integration.test.ts
import { describe, it, expect, beforeAll, afterAll, beforeEach } from "vitest";
import { createTRPCClient, httpBatchLink } from "@trpc/client";
import { createHTTPServer } from "@trpc/server/adapters/standalone";
import { appRouter } from "./_app";
import type { AppRouter } from "./_app";
import { PrismaClient } from "@prisma/client";
 
describe("User Router Integration", () => {
  let server: ReturnType<typeof createHTTPServer>;
  let client: ReturnType<typeof createTRPCClient<AppRouter>>;
  let prisma: PrismaClient;
 
  beforeAll(async () => {
    prisma = new PrismaClient({
      datasources: { db: { url: process.env.TEST_DATABASE_URL } },
    });
 
    server = createHTTPServer({
      router: appRouter,
      createContext: () => ({
        userId: "test-user-id",
        db: prisma,
      }),
    });
 
    // ランダムポートでサーバー起動
    const { port } = server.listen(0);
 
    client = createTRPCClient<AppRouter>({
      links: [
        httpBatchLink({
          url: `http://localhost:${port}`,
        }),
      ],
    });
  });
 
  afterAll(async () => {
    server.server.close();
    await prisma.$disconnect();
  });
 
  beforeEach(async () => {
    // テストごとにデータベースをクリーン
    await prisma.user.deleteMany();
  });
 
  it("should create and retrieve a user", async () => {
    // ユーザー作成
    const created = await client.user.create.mutate({
      name: "Integration Test User",
      email: "integration@test.com",
    });
 
    expect(created.id).toBeDefined();
    expect(created.name).toBe("Integration Test User");
 
    // 作成したユーザーを取得
    const retrieved = await client.user.byId.query({ id: created.id });
    expect(retrieved.name).toBe("Integration Test User");
    expect(retrieved.email).toBe("integration@test.com");
  });
 
  it("should paginate users correctly", async () => {
    // 25件のユーザーを作成
    await Promise.all(
      Array.from({ length: 25 }, (_, i) =>
        client.user.create.mutate({
          name: `User ${i}`,
          email: `user${i}@test.com`,
        })
      )
    );
 
    const page1 = await client.user.list.query({ page: 1, limit: 10 });
    expect(page1.users).toHaveLength(10);
    expect(page1.total).toBe(25);
 
    const page3 = await client.user.list.query({ page: 3, limit: 10 });
    expect(page3.users).toHaveLength(5);
  });
 
  it("should handle concurrent mutations safely", async () => {
    const user = await client.user.create.mutate({
      name: "Concurrent User",
      email: "concurrent@test.com",
    });
 
    // 同時に更新と削除を実行
    const results = await Promise.allSettled([
      client.user.update.mutate({
        id: user.id,
        data: { name: "Updated Name" },
      }),
      client.user.delete.mutate({ id: user.id }),
    ]);
 
    // 少なくとも1つは成功するはず
    const successes = results.filter((r) => r.status === "fulfilled");
    expect(successes.length).toBeGreaterThanOrEqual(1);
  });
});

// server/middleware/auth.test.ts
import { describe, it, expect, vi } from "vitest";
import { appRouter } from "../routers/_app";
import { TRPCError } from "@trpc/server";
 
describe("Auth Middleware", () => {
  const mockDb = {
    user: {
      findUnique: vi.fn(),
      findMany: vi.fn(),
    },
  } as unknown as PrismaClient;
 
  it("should reject unauthenticated requests to protected routes", async () => {
    const caller = appRouter.createCaller({
      userId: null, // 未認証
      db: mockDb,
    });
 
    await expect(
      caller.admin.listAllUsers()
    ).rejects.toThrow(TRPCError);
 
    await expect(
      caller.admin.listAllUsers()
    ).rejects.toMatchObject({
      code: "UNAUTHORIZED",
    });
  });
 
  it("should reject non-admin users from admin routes", async () => {
    (mockDb.user.findUnique as any).mockResolvedValue({
      id: "user-1",
      role: "USER", // 管理者ではない
    });
 
    const caller = appRouter.createCaller({
      userId: "user-1",
      db: mockDb,
    });
 
    await expect(
      caller.admin.listAllUsers()
    ).rejects.toMatchObject({
      code: "FORBIDDEN",
    });
  });
 
  it("should allow admin users to access admin routes", async () => {
    const mockUsers = [{ id: "1", name: "User" }];
    (mockDb.user.findUnique as any).mockResolvedValue({
      id: "admin-1",
      role: "ADMIN",
    });
    (mockDb.user.findMany as any).mockResolvedValue(mockUsers);
 
    const caller = appRouter.createCaller({
      userId: "admin-1",
      db: mockDb,
    });
 
    const result = await caller.admin.listAllUsers();
    expect(result).toEqual(mockUsers);
  });
});

// server/routers/chat.ts
import { observable } from "@trpc/server/observable";
import { z } from "zod";
import { EventEmitter } from "events";
import { router, protectedProcedure } from "../trpc";
 
// イベントエミッター（本番では Redis Pub/Sub を推奨）
const ee = new EventEmitter();
 
interface ChatMessage {
  id: string;
  roomId: string;
  userId: string;
  userName: string;
  content: string;
  createdAt: Date;
}
 
export const chatRouter = router({
  // メッセージ送信
  sendMessage: protectedProcedure
    .input(
      z.object({
        roomId: z.string(),
        content: z.string().min(1).max(2000),
      })
    )
    .mutation(async ({ ctx, input }) => {
      const message: ChatMessage = {
        id: crypto.randomUUID(),
        roomId: input.roomId,
        userId: ctx.userId,
        userName: ctx.user.name,
        content: input.content,
        createdAt: new Date(),
      };
 
      // DB に保存
      await ctx.db.message.create({ data: message });
 
      // イベントを発行（サブスクライバーに通知）
      ee.emit(`room:${input.roomId}`, message);
 
      return message;
    }),
 
  // リアルタイムメッセージ受信
  onMessage: protectedProcedure
    .input(z.object({ roomId: z.string() }))
    .subscription(({ input }) => {
      return observable<ChatMessage>((emit) => {
        const handler = (message: ChatMessage) => {
          emit.next(message);
        };
 
        // イベントリスナーを登録
        ee.on(`room:${input.roomId}`, handler);
 
        // クリーンアップ: クライアント切断時に呼ばれる
        return () => {
          ee.off(`room:${input.roomId}`, handler);
        };
      });
    }),
 
  // ユーザーのタイピング状態
  onTyping: protectedProcedure
    .input(z.object({ roomId: z.string() }))
    .subscription(({ input }) => {
      return observable<{ userId: string; userName: string }>((emit) => {
        const handler = (data: { userId: string; userName: string }) => {
          emit.next(data);
        };
 
        ee.on(`typing:${input.roomId}`, handler);
        return () => ee.off(`typing:${input.roomId}`, handler);
      });
    }),
 
  startTyping: protectedProcedure
    .input(z.object({ roomId: z.string() }))
    .mutation(({ ctx, input }) => {
      ee.emit(`typing:${input.roomId}`, {
        userId: ctx.userId,
        userName: ctx.user.name,
      });
      return { ok: true };
    }),
});

// utils/trpc.ts -- WebSocket リンク付き
import { createTRPCReact } from "@trpc/react-query";
import { createWSClient, wsLink, httpBatchLink, splitLink } from "@trpc/client";
import type { AppRouter } from "../server/routers/_app";
 
export const trpc = createTRPCReact<AppRouter>();
 
// WebSocket クライアント
const wsClient = createWSClient({
  url: "ws://localhost:3000/trpc",
  retryDelayMs: (attemptIndex) =>
    Math.min(1000 * 2 ** attemptIndex, 30_000), // 指数バックオフ
  onOpen: () => console.log("WebSocket connected"),
  onClose: () => console.log("WebSocket disconnected"),
});
 
export const trpcClient = trpc.createClient({
  links: [
    // splitLink でサブスクリプションだけ WebSocket を使う
    splitLink({
      condition: (op) => op.type === "subscription",
      true: wsLink({ client: wsClient }),
      false: httpBatchLink({
        url: "http://localhost:3000/api/trpc",
        headers: () => ({
          Authorization: `Bearer ${getToken()}`,
        }),
      }),
    }),
  ],
});

// components/ChatRoom.tsx
import { trpc } from "../utils/trpc";
import { useState } from "react";
 
export function ChatRoom({ roomId }: { roomId: string }) {
  const [messages, setMessages] = useState<ChatMessage[]>([]);
  const [input, setInput] = useState("");
  const [typingUsers, setTypingUsers] = useState<string[]>([]);
 
  // サブスクリプション: 新しいメッセージをリアルタイム受信
  trpc.chat.onMessage.useSubscription(
    { roomId },
    {
      onData: (message) => {
        setMessages((prev) => [...prev, message]);
      },
      onError: (err) => {
        console.error("Subscription error:", err);
      },
    }
  );
 
  // タイピング表示
  trpc.chat.onTyping.useSubscription(
    { roomId },
    {
      onData: ({ userName }) => {
        setTypingUsers((prev) => [...new Set([...prev, userName])]);
        // 3秒後に消す
        setTimeout(() => {
          setTypingUsers((prev) => prev.filter((u) => u !== userName));
        }, 3000);
      },
    }
  );
 
  const sendMessage = trpc.chat.sendMessage.useMutation();
  const startTyping = trpc.chat.startTyping.useMutation();
 
  const handleSend = async () => {
    if (!input.trim()) return;
    await sendMessage.mutateAsync({ roomId, content: input });
    setInput("");
  };
 
  return (
    <div>
      <div className="messages">
        {messages.map((msg) => (
          <div key={msg.id}>
            <strong>{msg.userName}</strong>: {msg.content}
          </div>
        ))}
      </div>
 
      {typingUsers.length > 0 && (
        <p>{typingUsers.join(", ")} is typing...</p>
      )}
 
      <input
        value={input}
        onChange={(e) => {
          setInput(e.target.value);
          startTyping.mutate({ roomId });
        }}
        onKeyDown={(e) => e.key === "Enter" && handleSend()}
      />
      <button onClick={handleSend}>Send</button>
    </div>
  );
}

// server/errors.ts
import { TRPCError } from "@trpc/server";
 
/**
 * ビジネスロジック用のカスタムエラー
 */
export class BusinessError extends TRPCError {
  public readonly errorCode: string;
 
  constructor(opts: {
    code: TRPCError["code"];
    message: string;
    errorCode: string;
    cause?: Error;
  }) {
    super({
      code: opts.code,
      message: opts.message,
      cause: opts.cause,
    });
    this.errorCode = opts.errorCode;
  }
}
 
// 具体的なエラー
export class InsufficientBalanceError extends BusinessError {
  constructor(balance: number, required: number) {
    super({
      code: "BAD_REQUEST",
      message: `Insufficient balance: have ${balance}, need ${required}`,
      errorCode: "INSUFFICIENT_BALANCE",
    });
  }
}
 
export class DuplicateEmailError extends BusinessError {
  constructor(email: string) {
    super({
      code: "CONFLICT",
      message: `Email ${email} is already registered`,
      errorCode: "DUPLICATE_EMAIL",
    });
  }
}
 
export class SubscriptionExpiredError extends BusinessError {
  constructor(expiredAt: Date) {
    super({
      code: "FORBIDDEN",
      message: `Subscription expired at ${expiredAt.toISOString()}`,
      errorCode: "SUBSCRIPTION_EXPIRED",
    });
  }
}

// server/trpc.ts -- 高度なエラーフォーマッター
import { initTRPC } from "@trpc/server";
import { ZodError } from "zod";
import { BusinessError } from "./errors";
 
const t = initTRPC.context<Context>().create({
  errorFormatter({ shape, error }) {
    return {
      ...shape,
      data: {
        ...shape.data,
        // Zod バリデーションエラーの詳細
        zodError:
          error.cause instanceof ZodError
            ? error.cause.flatten()
            : null,
        // ビジネスエラーコード
        businessCode:
          error instanceof BusinessError
            ? error.errorCode
            : null,
        // 開発環境のみスタックトレースを含める
        stack:
          process.env.NODE_ENV === "development"
            ? error.stack
            : undefined,
      },
    };
  },
});

// hooks/useTRPCError.ts
import { TRPCClientError } from "@trpc/client";
import type { AppRouter } from "../server/routers/_app";
import { toast } from "sonner";
 
/**
 * tRPC エラーを統一的にハンドリングするユーティリティ
 */
export function handleTRPCError(error: unknown) {
  if (!(error instanceof TRPCClientError<AppRouter>)) {
    toast.error("An unexpected error occurred");
    console.error("Non-tRPC error:", error);
    return;
  }
 
  const { data, message } = error;
 
  // Zod バリデーションエラー
  if (data?.zodError) {
    const fieldErrors = data.zodError.fieldErrors;
    const messages = Object.entries(fieldErrors)
      .map(([field, errors]) => `${field}: ${(errors as string[]).join(", ")}`)
      .join("\n");
    toast.error(`Validation Error:\n${messages}`);
    return;
  }
 
  // ビジネスエラー
  if (data?.businessCode) {
    switch (data.businessCode) {
      case "INSUFFICIENT_BALANCE":
        toast.error("Your balance is insufficient for this operation");
        break;
      case "DUPLICATE_EMAIL":
        toast.error("This email is already registered");
        break;
      case "SUBSCRIPTION_EXPIRED":
        toast.error("Your subscription has expired. Please renew.");
        break;
      default:
        toast.error(message);
    }
    return;
  }
 
  // HTTP ステータスベースのハンドリング
  switch (error.data?.httpStatus) {
    case 401:
      toast.error("Please log in to continue");
      // リダイレクト
      window.location.href = "/login";
      break;
    case 403:
      toast.error("You don't have permission to perform this action");
      break;
    case 429:
      toast.error("Too many requests. Please try again later.");
      break;
    default:
      toast.error(message || "Something went wrong");
  }
}
 
// React コンポーネントでの使用
function CreatePostForm() {
  const createPost = trpc.post.create.useMutation({
    onSuccess: (data) => {
      toast.success("Post created successfully!");
      router.push(`/posts/${data.id}`);
    },
    onError: handleTRPCError,
  });
 
  // ...
}