codeforlife 2.8.2 → 2.9.0

package/CONTRIBUTING.md

@@ -1,3 +0,0 @@
-# Contributing
-
-Find our contribution agreement [here](https://github.com/ocadotechnology/codeforlife-workspace/blob/main/CONTRIBUTING.md).

package/eslint.config.js

@@ -1,17 +0,0 @@
-import workspaceConfig from "@codeforlife/workspace/eslint.config.js"
-import ts from "typescript-eslint"
-
-export default ts.config(
-  ...workspaceConfig,
-  {
-    ignores: [
-      "src/scripts/*",
-      "src/server.js", // TODO: convert to src/server.ts and remove this ignore
-    ],
-  },
-  {
-    languageOptions: {
-      parserOptions: { tsconfigRootDir: import.meta.dirname },
-    },
-  },
-)

package/src/api/createApi.ts

@@ -1,91 +0,0 @@
-import {
-  type FetchArgs,
-  createApi as _createApi,
-  fetchBaseQuery,
-} from "@reduxjs/toolkit/query/react"
-
-import { SERVICE_API_URL } from "../settings"
-import { buildLogoutEndpoint } from "./endpoints/session"
-import defaultTagTypes from "./tagTypes"
-import { getCsrfCookie } from "../utils/auth"
-import { isSafeHttpMethod } from "../utils/api"
-
-// TODO: decide if we want to keep any of this.
-// export function handleResponseError(error: FetchBaseQueryError): void {
-//   if (
-//     error.status === 400 &&
-//     typeof error.data === "object" &&
-//     error.data !== null
-//   ) {
-//     // Parse the error's data from snake_case to camelCase.
-//     snakeCaseToCamelCase(error.data)
-//   } else if (error.status === 401) {
-//     // TODO: redirect to appropriate login page based on user type.
-//     window.location.href = `${PORTAL_BASE_URL}/login/teacher`
-//   } else {
-//     // Catch-all error pages by status-code.
-//     window.location.href = `${PORTAL_BASE_URL}/error/${
-//       [403, 404].includes(error.status as number) ? error.status : 500
-//     }`
-//   }
-// }
-
-export default function createApi<TagTypes extends string = never>({
-  tagTypes = [],
-}: {
-  tagTypes?: readonly TagTypes[]
-} = {}) {
-  const fetch = fetchBaseQuery({
-    baseUrl: `${SERVICE_API_URL}/`,
-    credentials: "include",
-    prepareHeaders: (headers, endpoint) => {
-      const { type, arg } = endpoint as typeof endpoint & {
-        arg: string | FetchArgs
-      }
-      const method = typeof arg === "string" ? "GET" : arg.method || "GET"
-
-      if (type === "mutation" || !isSafeHttpMethod(method)) {
-        const csrfToken = getCsrfCookie()
-        if (csrfToken) headers.set("x-csrftoken", csrfToken)
-      }
-
-      return headers
-    },
-  })
-
-  const api = _createApi({
-    // https://redux-toolkit.js.org/rtk-query/usage/customizing-queries#implementing-a-custom-basequery
-    baseQuery: async (args: string | FetchArgs, api, extraOptions) => {
-      if (api.type === "mutation" && getCsrfCookie() === undefined) {
-        // Get the CSRF token.
-        const { error } = await fetch(
-          { url: "/csrf/cookie/", method: "GET" },
-          api,
-          {},
-        )
-
-        // Validate we got the CSRF token.
-        if (error !== undefined) {
-          console.error(error)
-          // TODO
-          // window.location.href = `${PORTAL_BASE_URL}/error/500`
-        }
-        if (getCsrfCookie() === undefined) {
-          // TODO
-          // window.location.href = `${PORTAL_BASE_URL}/error/500`
-        }
-      }
-
-      // Send the HTTP request and fetch the response.
-      return await fetch(args, api, extraOptions)
-    },
-    tagTypes: [...defaultTagTypes, ...tagTypes],
-    endpoints: () => ({}),
-  })
-
-  return api.injectEndpoints({
-    endpoints: build => ({
-      logout: buildLogoutEndpoint<null, null>(api, build),
-    }),
-  })
-}

package/src/api/endpoints/authFactor.ts

@@ -1,31 +0,0 @@
-import { type EndpointBuilder } from "@reduxjs/toolkit/query/react"
-
-import {
-  type ListArg as _ListArg,
-  type ListResult as _ListResult,
-  buildUrl,
-  tagData,
-} from "../../utils/api"
-import type { AuthFactor } from "../models"
-import { type TagTypes } from "../tagTypes"
-import urls from "../urls"
-
-export const AUTH_FACTOR_TAG: TagTypes = "AuthFactor"
-
-export type ListAuthFactorsResult = _ListResult<AuthFactor, "type">
-export type ListAuthFactorsArg = _ListArg
-
-export default function getReadAuthFactorEndpoints<
-  ListResult extends _ListResult<AuthFactor> = ListAuthFactorsResult,
-  ListArg extends _ListArg<AuthFactor> = ListAuthFactorsArg,
->(build: EndpointBuilder<any, any, any>) {
-  return {
-    listAuthFactors: build.query<ListResult, ListArg>({
-      query: search => ({
-        url: buildUrl(urls.authFactor.list, { search }),
-        method: "GET",
-      }),
-      providesTags: tagData(AUTH_FACTOR_TAG, { includeListTag: true }),
-    }),
-  }
-}

package/src/api/endpoints/index.ts

@@ -1,9 +0,0 @@
-export * from "./authFactor"
-export { default as getReadAuthFactorEndpoints } from "./authFactor"
-export * from "./klass"
-export { default as getReadClassEndpoints } from "./klass"
-export * from "./school"
-export { default as getReadSchoolEndpoints } from "./school"
-export * from "./session"
-export * from "./user"
-export { default as getReadUserEndpoints } from "./user"

package/src/api/endpoints/klass.ts

@@ -1,87 +0,0 @@
-import { type EndpointBuilder } from "@reduxjs/toolkit/query/react"
-
-import type {
-  Class,
-  SchoolTeacher,
-  SchoolTeacherUser,
-  Teacher,
-} from "../models"
-import {
-  type ListArg as _ListArg,
-  type ListResult as _ListResult,
-  type RetrieveArg as _RetrieveArg,
-  type RetrieveResult as _RetrieveResult,
-  buildUrl,
-  tagData,
-} from "../../utils/api"
-import { type TagTypes } from "../tagTypes"
-import urls from "../urls"
-
-export const CLASS_TAG: TagTypes = "Class"
-
-export type RetrieveClassResult = _RetrieveResult<
-  Class,
-  "name" | "read_classmates_data" | "receive_requests_until" | "school"
-> & {
-  teacher: SchoolTeacher & {
-    user: Pick<
-      SchoolTeacherUser,
-      | "id"
-      | "first_name"
-      | "last_name"
-      | "email"
-      | "is_active"
-      | "date_joined"
-      | "requesting_to_join_class"
-    >
-  }
-}
-export type RetrieveClassArg = _RetrieveArg<Class>
-
-export type ListClassesResult = _ListResult<
-  Class,
-  "name" | "read_classmates_data" | "receive_requests_until" | "school",
-  {
-    teacher: SchoolTeacher & {
-      user: Pick<
-        SchoolTeacherUser,
-        | "id"
-        | "first_name"
-        | "last_name"
-        | "email"
-        | "is_active"
-        | "date_joined"
-        | "requesting_to_join_class"
-      >
-    }
-  }
->
-export type ListClassesArg = _ListArg<{
-  teacher: Teacher["id"]
-  _id: Class["id"] | Class["id"][]
-  id_or_name: string
-}>
-
-export default function getReadClassEndpoints<
-  RetrieveResult extends _RetrieveResult<Class> = RetrieveClassResult,
-  RetrieveArg extends _RetrieveArg<Class> = RetrieveClassArg,
-  ListResult extends _ListResult<Class> = ListClassesResult,
-  ListArg extends _ListArg<Class> = ListClassesArg,
->(build: EndpointBuilder<any, any, any>) {
-  return {
-    retrieveClass: build.query<RetrieveResult, RetrieveArg>({
-      query: id => ({
-        url: buildUrl(urls.class.detail, { url: { id } }),
-        method: "GET",
-      }),
-      providesTags: tagData(CLASS_TAG),
-    }),
-    listClasses: build.query<ListResult, ListArg>({
-      query: search => ({
-        url: buildUrl(urls.class.list, { search }),
-        method: "GET",
-      }),
-      providesTags: tagData(CLASS_TAG, { includeListTag: true }),
-    }),
-  }
-}

package/src/api/endpoints/school.ts

@@ -1,34 +0,0 @@
-import { type EndpointBuilder } from "@reduxjs/toolkit/query/react"
-
-import {
-  type RetrieveArg as _RetrieveArg,
-  type RetrieveResult as _RetrieveResult,
-  buildUrl,
-  tagData,
-} from "../../utils/api"
-import type { School } from "../models"
-import { type TagTypes } from "../tagTypes"
-import urls from "../urls"
-
-export const SCHOOL_TAG: TagTypes = "School"
-
-export type RetrieveSchoolResult = _RetrieveResult<
-  School,
-  "name" | "country" | "uk_county"
->
-export type RetrieveSchoolArg = _RetrieveArg<School>
-
-export default function getReadSchoolEndpoints<
-  RetrieveResult extends _RetrieveResult<School> = RetrieveSchoolResult,
-  RetrieveArg extends _RetrieveArg<School> = RetrieveSchoolArg,
->(build: EndpointBuilder<any, any, any>) {
-  return {
-    retrieveSchool: build.query<RetrieveResult, RetrieveArg>({
-      query: id => ({
-        url: buildUrl(urls.school.detail, { url: { id } }),
-        method: "GET",
-      }),
-      providesTags: tagData(SCHOOL_TAG),
-    }),
-  }
-}

package/src/api/endpoints/session.ts

@@ -1,47 +0,0 @@
-import { type Api, type EndpointBuilder } from "@reduxjs/toolkit/query/react"
-
-import { login, logout } from "../../slices/session"
-
-export type ExchangeOAuth2CodeArg = {
-  code: string
-  code_verifier: string
-  redirect_uri: string
-}
-
-export function buildLoginEndpoint<ResultType, QueryArg>(
-  build: EndpointBuilder<any, any, any>,
-  url: string = "session/login/",
-) {
-  return build.mutation<ResultType, QueryArg>({
-    query: body => ({ url, method: "POST", body }),
-    async onQueryStarted(_, { dispatch, queryFulfilled }) {
-      try {
-        await queryFulfilled
-        dispatch(login())
-      } catch (error) {
-        console.error("Failed to call login endpoint...", error)
-      }
-    },
-  })
-}
-
-export function buildLogoutEndpoint<ResultType, QueryArg>(
-  api: Api<any, any, any, any, any>,
-  build: EndpointBuilder<any, any, any>,
-  url: string = "session/logout/",
-) {
-  return build.mutation<ResultType, QueryArg>({
-    query: () => ({ url, method: "POST" }),
-    async onQueryStarted(_, { dispatch, queryFulfilled }) {
-      try {
-        await queryFulfilled
-      } catch (error) {
-        console.error("Failed to call logout endpoint...", error)
-      } finally {
-        dispatch(logout())
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
-        dispatch(api.util.resetApiState())
-      }
-    },
-  })
-}

package/src/api/endpoints/user.ts

@@ -1,70 +0,0 @@
-import { type EndpointBuilder } from "@reduxjs/toolkit/query/react"
-
-import type { Class, User } from "../models"
-import {
-  type ListArg as _ListArg,
-  type ListResult as _ListResult,
-  type RetrieveArg as _RetrieveArg,
-  type RetrieveResult as _RetrieveResult,
-  buildUrl,
-  tagData,
-} from "../../utils/api"
-import { type TagTypes } from "../tagTypes"
-import urls from "../urls"
-
-export const USER_TAG: TagTypes = "User"
-
-export type RetrieveUserResult = _RetrieveResult<
-  User,
-  | "first_name"
-  | "last_name"
-  | "email"
-  | "is_active"
-  | "date_joined"
-  | "requesting_to_join_class"
-  | "student"
-  | "teacher"
->
-export type RetrieveUserArg = _RetrieveArg<User>
-
-export type ListUsersResult = _ListResult<
-  User,
-  | "first_name"
-  | "last_name"
-  | "email"
-  | "is_active"
-  | "date_joined"
-  | "requesting_to_join_class"
-  | "student"
-  | "teacher"
->
-export type ListUsersArg = _ListArg<{
-  students_in_class: Class["id"]
-  _id: User["id"] | User["id"][]
-  name: string
-  type: "teacher" | "student" | "independent" | "indy"
-}>
-
-export default function getReadUserEndpoints<
-  RetrieveResult extends _RetrieveResult<User> = RetrieveUserResult,
-  RetrieveArg extends _RetrieveArg<User> = RetrieveUserArg,
-  ListResult extends _ListResult<User> = ListUsersResult,
-  ListArg extends _ListArg<User> = ListUsersArg,
->(build: EndpointBuilder<any, any, any>) {
-  return {
-    retrieveUser: build.query<RetrieveResult, RetrieveArg>({
-      query: id => ({
-        url: buildUrl(urls.user.detail, { url: { id } }),
-        method: "GET",
-      }),
-      providesTags: tagData(USER_TAG),
-    }),
-    listUsers: build.query<ListResult, ListArg>({
-      query: search => ({
-        url: buildUrl(urls.user.list, { search }),
-        method: "GET",
-      }),
-      providesTags: tagData(USER_TAG, { includeListTag: true }),
-    }),
-  }
-}

package/src/api/index.ts

@@ -1,5 +0,0 @@
-export { default as createApi } from "./createApi"
-export * from "./models"
-export * as schemas from "./schemas"
-export { default as tagTypes } from "./tagTypes"
-export { default as urls } from "./urls"

package/src/api/models.ts

@@ -1,145 +0,0 @@
-import type { CountryIsoCodes, UkCounties } from "../utils/general"
-import type { Model } from "../utils/api"
-
-// -----------------------------------------------------------------------------
-// User Models
-// -----------------------------------------------------------------------------
-
-type _UserTeacher<T extends Teacher> = Omit<T, "user">
-type _UserStudent<S extends Student> = Omit<S, "user" | "auto_gen_password">
-
-export type User = Model<
-  number,
-  {
-    password: string
-    last_login?: Date
-    first_name: string
-    last_name?: string
-    email?: string
-    is_staff: boolean
-    is_active: boolean
-    date_joined: Date
-    requesting_to_join_class?: Class["id"] | null
-    teacher?: _UserTeacher<Teacher>
-    student?: _UserStudent<Student>
-  }
->
-
-export type TeacherUser<Fields = User> = Fields & {
-  email: string
-  last_name: string
-  teacher: _UserTeacher<Teacher>
-  student?: undefined
-}
-
-export type SchoolTeacherUser<Fields = User> = TeacherUser<Fields> & {
-  teacher: _UserTeacher<SchoolTeacher>
-}
-
-export type AdminSchoolTeacherUser<Fields = User> =
-  SchoolTeacherUser<Fields> & {
-    teacher: _UserTeacher<AdminSchoolTeacher>
-  }
-
-export type NonAdminSchoolTeacherUser<Fields = User> =
-  SchoolTeacherUser<Fields> & {
-    teacher: _UserTeacher<NonAdminSchoolTeacher>
-  }
-
-export type NonSchoolTeacherUser<Fields = User> = TeacherUser<Fields> & {
-  teacher: _UserTeacher<NonSchoolTeacher>
-}
-
-export type StudentUser<Fields = User> = Fields & {
-  email?: undefined
-  last_name?: undefined
-  teacher?: undefined
-  student: _UserStudent<Student>
-}
-
-export type IndependentUser<Fields = User> = Fields & {
-  email: string
-  last_name: string
-  teacher?: undefined
-  student?: undefined
-}
-
-// -----------------------------------------------------------------------------
-// Teacher Models
-// -----------------------------------------------------------------------------
-
-export type Teacher = Model<
-  number,
-  {
-    user: User["id"]
-    school?: School["id"]
-    is_admin: boolean
-  }
->
-
-export type SchoolTeacher<Fields = Teacher> = Fields & {
-  school: School["id"]
-}
-
-export type AdminSchoolTeacher<Fields = Teacher> = SchoolTeacher<Fields> & {
-  is_admin: true
-}
-
-export type NonAdminSchoolTeacher<Fields = Teacher> = SchoolTeacher<Fields> & {
-  is_admin: false
-}
-
-export type NonSchoolTeacher<Fields = Teacher> = Fields & {
-  school?: undefined
-  is_admin: false
-}
-
-// -----------------------------------------------------------------------------
-// Other Models
-// -----------------------------------------------------------------------------
-
-export type Student = Model<
-  number,
-  {
-    user: User["id"]
-    school: School["id"]
-    klass: Class["id"]
-    auto_gen_password: string
-  }
->
-
-export type School = Model<
-  number,
-  {
-    name: string
-    country?: CountryIsoCodes
-    uk_county?: UkCounties
-  }
->
-
-export type Class = Model<
-  string,
-  {
-    name: string
-    teacher: Teacher["id"]
-    school: School["id"]
-    read_classmates_data: boolean
-    receive_requests_until?: Date
-  }
->
-
-export type AuthFactor = Model<
-  number,
-  {
-    user: User["id"]
-    type: "otp"
-  }
->
-
-export type OtpBypassToken = Model<
-  number,
-  {
-    user: User["id"]
-    token: string
-  }
->