API v1: all endpoints conform to OpenAPI spec

.vscode/launch.json

@@ -23,5 +23,18 @@
         "webRoot": "${workspaceFolder}"
       }
     },
+    {
+      "type": "node",
+      "request": "launch",
+      "name": "Debug Jest Tests",
+      "program": "${workspaceFolder}/node_modules/.bin/jest",
+      "args": ["--runInBand"],
+      "console": "integratedTerminal",
+      "internalConsoleOptions": "neverOpen",
+      "disableOptimisticBPs": true,
+      "windows": {
+        "program": "${workspaceFolder}/node_modules/jest/bin/jest"
+      }
+    },
   ]
 }

components/FilterControls.tsx

@@ -4,7 +4,7 @@ import { FunnelIcon } from "@heroicons/react/24/solid"
 import clsx from "clsx"
 import { AnimatePresence, motion } from "framer-motion"
 import { ReactElement, ReactNode, useEffect, useState } from "react"
-import { ExtraFilters } from "../lib/web/question_router"
+import { ExtraFilters } from "../lib/web/question_router/types"
 
 function FilterButton({
   onClick,

components/Questions.tsx

@@ -5,7 +5,7 @@ import { LoaderIcon } from "react-hot-toast"
 import { InView } from "react-intersection-observer"
 import ReactMarkdown from "react-markdown"
 import remarkGfm from "remark-gfm"
-import { ExtraFilters } from "../lib/web/question_router"
+import { ExtraFilters } from "../lib/web/question_router/types"
 import { api } from "../lib/web/trpc"
 import { FilterControls } from "./FilterControls"
 import { Question } from "./questions/Question"

components/questions/QuestionOrSignIn.tsx

@@ -18,7 +18,7 @@ export function QuestionOrSignIn({
   const { data: session, status: authStatus } = useSession()
 
   const questionId = useQuestionId()
-  const qQuery = api.question.getQuestion.useQuery(
+  const qQuery = api.legacyQuestion.getQuestion.useQuery(
     { questionId },
     { retry: false },
   )

jest.config.ts

@@ -10,7 +10,21 @@ const createJestConfig = nextJest({
   dir: "./",
 })
 
-const config: Config = {
+// Allows jest to be able to use ESM correctly in test setup
+const esModules = [
+  "@panva/hkdf",
+  "data-uri-to-buffer",
+  "fetch-blob",
+  "formdata-polyfill",
+  "jose",
+  "node-fetch",
+  "preact",
+  "preact-render-to-string",
+  "superjson",
+  "uncrypto",
+  "uuid",
+]
+const customConfig: Config = {
   clearMocks: true,
   collectCoverage: false,
   coverageDirectory: "coverage",
@@ -20,7 +34,18 @@ const config: Config = {
     "!**/vendor/**",
   ],
   coverageProvider: "v8",
+  // setupFilesAfterEnv: ["<rootDir>/jest.setup.ts"], - can uncomment when jest.setup.ts is reintroduced
   testEnvironment: "jsdom",
+  transformIgnorePatterns: [`/node_modules/(?!(${esModules.join("|")})/)`],
 }
 
-export default createJestConfig(config)
+module.exports = async () => {
+  const jestConfig = await createJestConfig(customConfig)()
+  return {
+    ...jestConfig,
+    transformIgnorePatterns:
+      jestConfig.transformIgnorePatterns?.filter(
+        (ptn) => ptn !== "/node_modules/",
+      ) ?? [],
+  }
+}

lib/interactive_handlers/postFromWeb.ts

@@ -8,9 +8,9 @@ import {
 } from "../_utils_server"
 import { buildQuestionBlocks } from "../blocks-designs/question"
 import prisma from "../prisma"
-import { assertHasAccess } from "../web/question_router"
 import { getQuestionIdFromUrl } from "../web/question_url"
 import { getTournamentUrl, getUserListUrl } from "../web/utils"
+import { assertHasAccess } from "../web/question_router/assert"
 
 export async function postFromWeb(
   relativePath: string,

lib/web/app_router.ts

@@ -9,15 +9,17 @@ import {
 import prisma from "../prisma"
 import { feedbackRouter } from "./feedback_router"
 import { importRouter } from "./import_router"
-import { questionRouter } from "./question_router"
 import { tagsRouter } from "./tags_router"
 import { tournamentRouter } from "./tournament_router"
 import { getClientBaseUrl } from "./trpc"
 import { publicProcedure, router } from "./trpc_base"
 import { userListRouter } from "./userList_router"
+import { questionRouter } from "./question_router/v1/question_router"
+import { questionRouter as legacyQuestionRouter } from "./question_router/v0/question_router"
 
 export const appRouter = router({
   question: questionRouter,
+  legacyQuestion: legacyQuestionRouter,
   userList: userListRouter,
   tags: tagsRouter,
   import: importRouter,

lib/web/question_router/__tests__/assert.test.ts

@@ -0,0 +1,70 @@
+import { assertHasAccess } from "../assert"
+import { TRPCError } from "@trpc/server"
+import { QuestionWithForecastsAndSharedWithAndLists } from "../../../../prisma/additional"
+import { User } from "@prisma/client"
+
+describe("assertHasAccess", () => {
+  const mockUser: User = { id: "user1", email: "[email protected]" } as User
+  const mockQuestion: QuestionWithForecastsAndSharedWithAndLists = {
+    id: "1",
+    title: "Test Question",
+    userId: "user2",
+    createdAt: new Date(),
+    comment: null,
+    profileId: null,
+    type: "BINARY",
+    resolveBy: new Date(),
+    resolved: false,
+    pingedForResolution: false,
+    resolution: null,
+    resolvedAt: null,
+    notes: null,
+    hideForecastsUntil: null,
+    exclusiveAnswers: null,
+    sharedPublicly: false,
+    sharedWith: [],
+    sharedWithLists: [],
+    forecasts: [],
+    hideForecastsUntilPrediction: null,
+    unlisted: false,
+  } as QuestionWithForecastsAndSharedWithAndLists
+
+  it("should throw error if question is null", () => {
+    expect(() => assertHasAccess(null, mockUser)).toThrow(TRPCError)
+  })
+
+  it("should not throw error if question is shared publicly", () => {
+    const publicQuestion = { ...mockQuestion, sharedPublicly: true }
+    expect(() => assertHasAccess(publicQuestion, mockUser)).not.toThrow()
+  })
+
+  it("should not throw error if user is the question owner", () => {
+    const ownedQuestion = { ...mockQuestion, userId: "user1" }
+    expect(() => assertHasAccess(ownedQuestion, mockUser)).not.toThrow()
+  })
+
+  it("should throw error if user has no access", () => {
+    expect(() => assertHasAccess(mockQuestion, mockUser)).toThrow(TRPCError)
+  })
+
+  it("should not throw error if question is shared with user", () => {
+    const sharedQuestion = {
+      ...mockQuestion,
+      sharedWith: [
+        {
+          id: "user1",
+          name: "User One",
+          createdAt: new Date(),
+          email: "[email protected]",
+          image: null,
+          staleReminder: false,
+          unsubscribedFromEmailsAt: null,
+          apiKey: "apiKey1",
+          discordUserId: null,
+          emailVerified: null,
+        },
+      ],
+    }
+    expect(() => assertHasAccess(sharedQuestion, mockUser)).not.toThrow()
+  })
+})

lib/web/question_router/__tests__/email_shared.test.ts

@@ -0,0 +1,110 @@
+import { emailNewlySharedWithUsers } from "../email_shared"
+import prisma from "../../../prisma"
+import { createNotification, sendEmailUnbatched } from "../../notifications"
+import { getQuestionUrl } from "../../question_url"
+import { QuestionWithUserAndSharedWith } from "../../../../prisma/additional"
+import { QuestionType } from "@prisma/client"
+
+jest.mock("../../../prisma", () => ({
+  user: {
+    findUnique: jest.fn(),
+  },
+}))
+
+jest.mock("../../notifications", () => ({
+  createNotification: jest.fn(),
+  sendEmailUnbatched: jest.fn(),
+  fatebookEmailFooter: jest.fn().mockReturnValue(""),
+}))
+
+jest.mock("../../question_url", () => ({
+  getQuestionUrl: jest.fn(),
+}))
+
+describe("emailNewlySharedWithUsers", () => {
+  const mockQuestion: QuestionWithUserAndSharedWith = {
+    id: "q1",
+    title: "Test Question",
+    user: {
+      id: "user-id",
+      name: "Test User",
+      email: "[email protected]",
+      createdAt: new Date(),
+      image: null,
+      staleReminder: false,
+      unsubscribedFromEmailsAt: null,
+      apiKey: null,
+      discordUserId: null,
+      emailVerified: null,
+      profiles: []
+    },
+    sharedWith: [],
+    createdAt: new Date(),
+    comment: null,
+    profileId: null,
+    type: QuestionType.BINARY,
+    resolveBy: new Date(),
+    resolved: false,
+    pingedForResolution: false,
+    exclusiveAnswers: null,
+    resolution: null,
+    resolvedAt: null,
+    notes: null,
+    hideForecastsUntil: null,
+    hideForecastsUntilPrediction: null,
+    userId: "u1",
+    sharedPublicly: false,
+    unlisted: false,
+  } as QuestionWithUserAndSharedWith
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+    ;(getQuestionUrl as jest.Mock).mockReturnValue("http://example.com/q1")
+  })
+
+  it("should create notification for existing users", async () => {
+    const existingUser = { id: "u2", email: "[email protected]" }
+    ;(prisma.user.findUnique as jest.Mock).mockResolvedValue(existingUser)
+
+    await emailNewlySharedWithUsers(["[email protected]"], mockQuestion)
+
+    expect(createNotification).toHaveBeenCalledWith({
+      userId: "u2",
+      title: "Test User shared a prediction with you",
+      content: "Test User shared a prediction with you",
+      url: "http://example.com/q1",
+      tags: ["shared_prediction", "q1"],
+      questionId: "q1",
+    })
+    expect(sendEmailUnbatched).not.toHaveBeenCalled()
+  })
+
+  it("should send email for non-existing users", async () => {
+    ;(prisma.user.findUnique as jest.Mock).mockResolvedValue(null)
+
+    await emailNewlySharedWithUsers(["[email protected]"], mockQuestion)
+
+    expect(sendEmailUnbatched).toHaveBeenCalledWith(
+      expect.objectContaining({
+        to: "[email protected]",
+        subject: "Test User shared a prediction with you",
+      }),
+    )
+    expect(createNotification).not.toHaveBeenCalled()
+  })
+
+  it("should handle multiple users", async () => {
+    const existingUser = { id: "u2", email: "[email protected]" }
+    ;(prisma.user.findUnique as jest.Mock)
+      .mockResolvedValueOnce(existingUser)
+      .mockResolvedValueOnce(null)
+
+    await emailNewlySharedWithUsers(
+      ["[email protected]", "[email protected]"],
+      mockQuestion,
+    )
+
+    expect(createNotification).toHaveBeenCalledTimes(1)
+    expect(sendEmailUnbatched).toHaveBeenCalledTimes(1)
+  })
+})