Merge Changes into Main from Canary (v3.5.0-5abefb29)

.prettierignore

@@ -1 +1,2 @@
-/config/eslint_rules/color-mode-styles/*.js
+/config/eslint_rules/color-mode-styles/*.js
+src/i18n/locales/*.ts

cypress/support/commands.ts

@@ -204,8 +204,8 @@ Cypress.Commands.add('simulatePracticeSelection', (question, options = {}) => {
   }
 })
 
-Cypress.Commands.add('insertKnowledgeCheck', (check) => {
-  cy.request('POST', '/api/insert/knowledgeCheck', check).should('have.property', 'status').and('eq', 200)
+Cypress.Commands.add('insertCourse', (course) => {
+  cy.request('POST', '/api/insert/course', course).should('have.property', 'status').and('eq', 200)
 })
 
 Cypress.Commands.add('loginAnonymously', () => {

cypress/support/i18n.ts

@@ -0,0 +1,42 @@
+/* eslint-disable unused-imports/no-unused-imports */
+/* eslint-disable simple-import-sort/imports */
+// cypress/support/i18n.ts
+import messagesEn from '../../src/i18n/locales/en'
+import messagesDe from '../../src/i18n/locales/de'
+import { FlattenedTranslations, TranslationKeys, TranslationValue, Translator } from '@/src/i18n/locales/types'
+import type { CreateParams, LocaleValue, ParamsObject } from 'international-types'
+import { Any } from '@/types'
+
+type Messages = Record<string, unknown>
+
+function getByPath(obj: Messages, key: string): unknown {
+  return key.split('.').reduce<unknown>((acc, part) => {
+    if (acc && typeof acc === 'object' && part in (acc as Record<string, unknown>)) {
+      return (acc as Record<string, unknown>)[part]
+    }
+    return undefined
+  }, obj)
+}
+
+function interpolate(template: string, params?: Record<string, string | number>) {
+  if (!params) return template
+
+  return template.replace(/\{(\w+)\}/g, (_, name) => {
+    const value = params[name]
+    return value == null ? `{${name}}` : String(value)
+  })
+}
+
+/**
+ * This utility function initializes a i18n translator function that may be used within tests to e.g. pass along to schema-utility functions
+ * @param locale The language 'de' | 'en' that should be used, by default 'en'.
+ * @returns The translator function that is identical to i18n's `t`.
+ */
+export function createTranslator(locale: 'de' | 'en' = 'en') {
+  const messages = locale === 'de' ? messagesDe : messagesEn
+
+  return ((key: string, params?: Any) => {
+    const raw = getByPath(messages, key) as string | undefined
+    return typeof raw === 'string' ? interpolate(raw, params) : key
+  }) as unknown as Translator
+}

cypress/support/index.d.ts

@@ -34,7 +34,7 @@ declare namespace Cypress {
 
     removeDBUser(email: string, username: string): void
 
-    insertKnowledgeCheck(check: KnowledgeCheck): void
+    insertCourse(course: Course): void
 
     dragDrop(dragLocator: Cypress.Chainable<JQuery<HTMLElement>>, dropLocator: Cypress.Chainable<JQuery<HTMLElement>>): void
 

database/cleanup/cleanup-test-data.ts

@@ -3,7 +3,7 @@ import * as dotenv from 'dotenv'
 import { eq } from 'drizzle-orm'
 import deleteUser from '@/database/cleanup/deleteUser'
 import getDatabase from '@/database/Database'
-import { db_knowledgeCheck, db_user } from '@/database/drizzle/schema'
+import { db_course, db_user } from '@/database/drizzle/schema'
 
 dotenv.config()
 
@@ -24,9 +24,9 @@ async function cleanupTestData() {
     process.exit(1)
   }
 
-  await db.delete(db_knowledgeCheck).where(eq(db_knowledgeCheck.owner_id, users.at(0)!.userId))
+  await db.delete(db_course).where(eq(db_course.owner_id, users.at(0)!.userId))
 
-  console.log(`Deleted all KnowledgeChecks created by the test-user with the email ${testEmail}`)
+  console.log(`Deleted all Courses created by the test-user with the email ${testEmail}`)
 
   await deleteUser({ email: 'e2e.user@example.test' })
   await deleteUser({ name: 'Anonymous' }, { limit: -1 })

database/knowledgeCheck/catagories/insert.ts → database/course/catagories/insert.ts

@@ -2,25 +2,25 @@ import 'server-only'
 import { and, eq } from 'drizzle-orm'
 import getDatabase, { DrizzleDB } from '@/database/Database'
 import { db_category } from '@/database/drizzle/schema'
-import { KnowledgeCheck } from '@/src/schemas/KnowledgeCheck'
+import { Course } from '@/src/schemas/CourseSchema'
 // eslint-disable-next-line @typescript-eslint/no-unused-vars, unused-imports/no-unused-imports
 import { Any } from '@/types'
 
-export async function insertQuestionCategories(db: DrizzleDB | undefined, checkId: KnowledgeCheck['id'], categories: KnowledgeCheck['questionCategories']) {
+export async function insertQuestionCategories(db: DrizzleDB | undefined, courseId: Course['id'], categories: Course['questionCategories']) {
   if (!db) db = await getDatabase()
 
   const insertedCategories: Awaited<ReturnType<typeof insertCategory>>[] = []
 
   for (const category of categories) {
-    const insertion = await insertCategory(db, { ...category, knowledgecheckId: checkId })
+    const insertion = await insertCategory(db, { ...category, knowledgecheckId: courseId })
     insertedCategories.push(insertion)
   }
 
   return insertedCategories
 }
 
 /**
- * This function inserts a new category that is associated to a given check. When a category that already exists is inserted again the duplicate-entry-error is caught and the respective category is selected instead.
+ * This function inserts a new category that is associated to a given course. When a category that already exists is inserted again the duplicate-entry-error is caught and the respective category is selected instead.
  * @param db The database / db-transaction to use
  * @param props The category-props that are to be inserted
  * @returns The inserted data / retrieved category that was already inserted

database/knowledgeCheck/catagories/select.ts → database/course/catagories/select.ts

@@ -2,10 +2,10 @@ import 'server-only'
 import { eq } from 'drizzle-orm'
 import getDatabase from '@/database/Database'
 import { db_category } from '@/database/drizzle/schema'
-import { KnowledgeCheck } from '@/src/schemas/KnowledgeCheck'
+import { Course } from '@/src/schemas/CourseSchema'
 
-export async function getCategoriesByCheckId(knowledgeCheckId: KnowledgeCheck['id']) {
+export async function getCategoriesByCourseId(courseId: Course['id']) {
   const db = await getDatabase()
 
-  return await db.select().from(db_category).where(eq(db_category.knowledgecheckId, knowledgeCheckId))
+  return await db.select().from(db_category).where(eq(db_category.knowledgecheckId, courseId))
 }

database/course/catagories/update.ts

@@ -0,0 +1,13 @@
+import { eq } from 'drizzle-orm'
+import { insertQuestionCategories } from '@/database/course/catagories/insert'
+import { DrizzleDB } from '@/database/Database'
+import { db_category } from '@/database/drizzle'
+import { Course } from '@/src/schemas/CourseSchema'
+
+export async function updateCategories(db: DrizzleDB, courseId: Course['id'], categories: Course['questionCategories']) {
+  await db.delete(db_category).where(eq(db_category.knowledgecheckId, courseId))
+
+  if (categories.length === 0) return
+
+  await insertQuestionCategories(db, courseId, categories)
+}

database/course/collaborators/insert.ts

@@ -0,0 +1,11 @@
+import { DrizzleDB } from '@/database/Database'
+import { db_userContributesToCourse } from '@/database/drizzle/schema'
+import { Course } from '@/src/schemas/CourseSchema'
+
+export async function insertCollaboratorsToCourse(db: DrizzleDB, courseId: Course['id'], collaborators: Course['collaborators']) {
+  if (collaborators.length === 0) return
+
+  const values: (typeof db_userContributesToCourse.$inferInsert)[] = collaborators.map((collaboratorId) => ({ knowledgecheckId: courseId, userId: collaboratorId }))
+
+  await db.insert(db_userContributesToCourse).values(values)
+}

database/course/collaborators/select.ts

@@ -0,0 +1,10 @@
+import { eq } from 'drizzle-orm'
+import getDatabase from '@/database/Database'
+import { db_userContributesToCourse } from '@/database/drizzle/schema'
+import { Course } from '@/src/schemas/CourseSchema'
+
+export async function getCourseCollaborators(courseId: Course['id']) {
+  const db = await getDatabase()
+
+  return await db.select({ userId: db_userContributesToCourse.userId }).from(db_userContributesToCourse).where(eq(db_userContributesToCourse.knowledgecheckId, courseId))
+}

database/course/collaborators/update.ts

@@ -0,0 +1,13 @@
+import 'server-only'
+import { eq } from 'drizzle-orm'
+import { DrizzleDB } from '@/database/Database'
+import { db_userContributesToCourse } from '@/database/drizzle'
+import { Course } from '@/src/schemas/CourseSchema'
+
+export async function updateCollaborators(db: DrizzleDB, courseId: Course['id'], newCollaborators: Course['collaborators']) {
+  await db.delete(db_userContributesToCourse).where(eq(db_userContributesToCourse.knowledgecheckId, courseId))
+
+  if (newCollaborators.length === 0) return
+
+  await db.insert(db_userContributesToCourse).values(newCollaborators.map((collabId) => ({ knowledgecheckId: courseId, userId: collabId })))
+}

database/course/delete.ts

@@ -0,0 +1,18 @@
+'use server'
+
+import { and, eq } from 'drizzle-orm'
+import getDatabase from '@/database/Database'
+import { db_course } from '@/database/drizzle/schema'
+import requireAuthentication from '@/src/lib/auth/requireAuthentication'
+import { Course } from '@/src/schemas/CourseSchema'
+
+export async function removeCourse({ courseId }: { courseId: Course['id'] }) {
+  const {
+    user: { id: userId },
+  } = await requireAuthentication()
+
+  const db = await getDatabase()
+
+  const result = await db.delete(db_course).where(and(eq(db_course.id, courseId), eq(db_course.owner_id, userId)))
+  return result[0].affectedRows > 0
+}

database/course/insert.ts

@@ -0,0 +1,64 @@
+'use server'
+
+import { eq } from 'drizzle-orm'
+import { insertQuestionCategories } from '@/database/course/catagories/insert'
+import { insertCollaboratorsToCourse } from '@/database/course/collaborators/insert'
+import insertCourseQuestions from '@/database/course/questions/insert'
+import insertCourseSettings from '@/database/course/settings/insert'
+import getDatabase from '@/database/Database'
+import { db_course } from '@/database/drizzle/schema'
+import requireAuthentication from '@/src/lib/auth/requireAuthentication'
+import _logger from '@/src/lib/log/Logger'
+import { formatDatetime } from '@/src/lib/Shared/formatDatetime'
+import { Course } from '@/src/schemas/CourseSchema'
+
+const logger = _logger.createModuleLogger('/' + import.meta.url.split('/').reverse().slice(0, 2).reverse().join('/')!)
+
+export default async function insertCourse(course: Course) {
+  await requireAuthentication()
+
+  const db = await getDatabase()
+  await db.transaction(async (transaction) => {
+    try {
+      const [{ id }] = await transaction
+        .insert(db_course)
+        .values({
+          id: course.id,
+          name: course.name,
+          description: course.description,
+          difficulty: course.difficulty,
+          share_key: course.share_key,
+          owner_id: course.owner_id,
+          openDate: formatDatetime(course.openDate),
+          closeDate: course.closeDate ? formatDatetime(course.closeDate) : null,
+          contents: course.contents,
+        })
+        .$returningId()
+
+      if (!id) throw new Error('Database insert statement did not return inserted-`id`')
+
+      await insertCollaboratorsToCourse(transaction, course.id, course.collaborators)
+      await insertCourseSettings(transaction, course)
+      const categories = await insertQuestionCategories(transaction, id, course.questionCategories)
+      const questionsWithCategoryIds = course.questions.map((q) => {
+        const category = categories.find((c) => c.name === q.category)
+
+        if (!category) throw new Error(`Category "${q.category}" not found for question "${q.id}"`)
+
+        return { ...q, categoryId: category.id }
+      })
+
+      await insertCourseQuestions(transaction, questionsWithCategoryIds, id)
+    } catch (err) {
+      logger.info('[Rollback]: Inserting db_knowledgecheck was unsuccessful!', err)
+      transaction.rollback()
+    }
+  })
+}
+
+export async function storeCourseShareToken(check_id: Course['id'], token: string) {
+  await requireAuthentication()
+  const db = await getDatabase()
+
+  await db.update(db_course).set({ share_key: token }).where(eq(db_course.id, check_id))
+}

database/knowledgeCheck/query.ts → database/course/query.ts

@@ -1,16 +1,23 @@
+'use server'
+
 import { BuildQueryResult, DBQueryConfig, ExtractTablesWithRelations } from 'drizzle-orm'
+import { convertSettings } from '@/database/course/settings/transform'
+import { DatabaseOptions } from '@/database/course/type'
 import getDatabase from '@/database/Database'
 import { DrizzleSchema } from '@/database/drizzle'
-import { convertSettings } from '@/database/knowledgeCheck/settings/transform'
-import { DatabaseOptions } from '@/database/knowledgeCheck/type'
-import buildKnowledgeCheckWhere, { KnowledgeCheckFilterBundle } from '@/database/utils/buildKnowledgeCheckWhere'
-import { KnowledgeCheck, safeParseKnowledgeCheck } from '@/src/schemas/KnowledgeCheck'
-import { instantiateKnowledgeCheckSettings, KnowledgeCheckSettings } from '@/src/schemas/KnowledgeCheckSettingsSchema'
+import buildCourseWhere, { CourseFilterBundle } from '@/database/utils/buildCourseWhere'
+import { Translator } from '@/src/i18n/locales/types'
+import { getI18n } from '@/src/i18n/server-localization'
+import _logger from '@/src/lib/log/Logger'
+import { Course, safeParseCourse } from '@/src/schemas/CourseSchema'
+import { CourseSettings, instantiateCourseSettings } from '@/src/schemas/CourseSettingsSchema'
 import { ChoiceQuestion, DragDropQuestion, OpenQuestion, Question } from '@/src/schemas/QuestionSchema'
 import { Any } from '@/types'
 
+const logger = _logger.createModuleLogger('/' + import.meta.url.split('/').reverse().slice(0, 2).reverse().join('/')!)
+
 //* joins the knowledgeCheck table with the following tables and aggregates the results: `Settings`, `Questions`, `Answers` and `Category`
-const knowledgeCheckWithAllConfig = {
+const courseWithAllConfig = {
   userContributesToKnowledgeChecks: {
     columns: {
       knowledgecheckId: false,
@@ -47,56 +54,57 @@ const knowledgeCheckWithAllConfig = {
       },
     },
   },
-} as const satisfies KcWith
+} as const satisfies CourseWith
 
 type Tables = ExtractTablesWithRelations<DrizzleSchema>
-type KcTable = Tables['db_knowledgeCheck']
-type KcWith = DBQueryConfig<'one' | 'many', boolean, Tables, KcTable>['with']
+type CourseTable = Tables['db_course']
+type CourseWith = DBQueryConfig<'one' | 'many', boolean, Tables, CourseTable>['with']
 
-type KnowledgeCheckTableConfig = Tables['db_knowledgeCheck']
+type CourseTableConfig = Tables['db_course']
 
-export type KnowledgeCheckWithAll = BuildQueryResult<Tables, KnowledgeCheckTableConfig, { with: typeof knowledgeCheckWithAllConfig }>
+export type CourseWithAll = BuildQueryResult<Tables, CourseTableConfig, { with: typeof courseWithAllConfig }>
 
-export async function getKnowledgeChecks({ limit = 10, offset, ...filterBundle }: {} & KnowledgeCheckFilterBundle & DatabaseOptions = {}): Promise<KnowledgeCheck[]> {
+export async function getCourses({ limit = 10, offset, ...filterBundle }: {} & CourseFilterBundle & DatabaseOptions = {}): Promise<Course[]> {
+  const t = await getI18n()
   const db = await getDatabase()
 
-  const checks = await db.query.db_knowledgeCheck.findMany({
-    where: buildKnowledgeCheckWhere(db, filterBundle),
-    with: knowledgeCheckWithAllConfig,
+  const courses = await db.query.db_course.findMany({
+    where: buildCourseWhere(db, filterBundle),
+    with: courseWithAllConfig,
     orderBy: (kc, { desc }) => [desc(kc.updatedAt)],
     limit: limit,
     offset,
   })
 
-  return checks.map(parseCheck).filter((check) => check !== null)
+  return courses.map((c) => parseCourse({ ...c, t })).filter((course) => course !== null)
 }
 
-function parseCheck({ questions, knowledgeCheckSettings: settings, categories, userContributesToKnowledgeChecks: collaboratorIds, ...check }: KnowledgeCheckWithAll): KnowledgeCheck | null {
-  const result = safeParseKnowledgeCheck({
-    ...check,
+function parseCourse({ t, questions, knowledgeCheckSettings: settings, categories, userContributesToKnowledgeChecks: collaboratorIds, ...course }: CourseWithAll & { t: Translator }): Course | null {
+  const result = safeParseCourse(t, {
+    ...course,
     collaborators: collaboratorIds.map((c) => c.userId),
     questions: questions.map(parseQuestion),
-    questionCategories: categories.map((c): KnowledgeCheck['questionCategories'][number] => ({
+    questionCategories: categories.map((c): Course['questionCategories'][number] => ({
       ...c,
       skipOnMissingPrequisite: false,
     })),
-    settings: parseSetting(settings),
+    settings: parseSetting(t, settings),
   })
 
   if (!result.success) {
-    console.error(`Failed to parse knowledgeCheck instance ${check.id} because: `, result.error)
+    logger.error(`Failed to parse course instance ${course.id} because: `, result.error)
   }
 
   return result.data ?? null
 }
 
-function parseQuestion({ category, answers, ...question }: KnowledgeCheckWithAll['questions'][number]): Question {
+function parseQuestion({ category, answers, ...question }: CourseWithAll['questions'][number]): Question {
   return { ...question, type: question.type as Any, category: category.name, ...parseAnswers(question.type, answers) }
 }
 
 function parseAnswers(
   question_type: Question['type'],
-  answers: KnowledgeCheckWithAll['questions'][number]['answers'],
+  answers: CourseWithAll['questions'][number]['answers'],
 ): Pick<ChoiceQuestion, 'answers'> | Pick<OpenQuestion, 'expectation'> | Pick<DragDropQuestion, 'answers'> {
   switch (question_type) {
     case 'multiple-choice':
@@ -130,6 +138,6 @@ function parseAnswers(
   }
 }
 
-function parseSetting(setting: KnowledgeCheckWithAll['knowledgeCheckSettings']): KnowledgeCheckSettings {
-  return convertSettings('from-database', setting) ?? instantiateKnowledgeCheckSettings()
+function parseSetting(t: Translator, setting: CourseWithAll['knowledgeCheckSettings']): CourseSettings {
+  return convertSettings('from-database', setting, t) ?? instantiateCourseSettings(t)
 }