am calling canvas api

nextjs/src/services/axiosUtils.ts

@@ -1,8 +1,26 @@
+import { isServer } from "@tanstack/react-query";
 import axios, { AxiosInstance, AxiosError } from "axios";
 import toast from "react-hot-toast";
 
 export const axiosClient: AxiosInstance = axios.create();
 
+if (!isServer) {
+  console.log("not on the server, setting up interceptor");
+  axiosClient.interceptors.request.use((config) => {
+    if (
+      config.url &&
+      config.url.startsWith("https://snow.instructure.com/api/v1/")
+    ) {
+      const newUrl = config.url.replace(
+        "https://snow.instructure.com/api/v1/",
+        "/api/canvas/"
+      );
+      config.url = newUrl;
+    }
+    return config;
+  });
+}
+
 axiosClient.interceptors.response.use(
   (response) => response,
   (error: AxiosError) => {

nextjs/src/services/canvas/canvasPageService.ts

@@ -0,0 +1,65 @@
+import { CanvasPage } from "@/models/canvas/pages/canvasPageModel";
+import { LocalCoursePage } from "@/models/local/page/localCoursePage";
+import { canvasServiceUtils } from "./canvasServiceUtils";
+import { webRequestor } from "./webRequestor";
+
+const baseCanvasUrl = "https://snow.instructure.com/api/v1";
+
+export const canvasPageService = {
+  async getAll(courseId: number): Promise<CanvasPage[]> {
+    const url = `${baseCanvasUrl}/courses/${courseId}/pages`;
+    const pages = await canvasServiceUtils.paginatedRequest<CanvasPage[]>({
+      url,
+    });
+    return pages.flatMap((pageList) => pageList);
+  },
+
+  // async create(canvasCourseId: number, localCourse: LocalCoursePage): Promise<CanvasPage> {
+  //   console.log(`Creating course page: ${localCourse.name}`);
+  //   const url = `courses/${canvasCourseId}/pages`;
+  //   const body = {
+  //     wiki_page: {
+  //       title: localCourse.name,
+  //       body: localCourse.getBodyHtml(),
+  //     },
+  //   };
+
+  //   const { canvasPage, response } = await webRequestor.post<CanvasPage>({
+  //     url,
+  //     body,
+  //   });
+
+  //   if (!canvasPage) {
+  //     throw new Error("Created canvas course page was null");
+  //   }
+
+  //   return canvasPage;
+  // },
+
+  // async update(courseId: number, canvasPageId: number, localCoursePage: LocalCoursePage): Promise<void> {
+  //   console.log(`Updating course page: ${localCoursePage.name}`);
+  //   const url = `courses/${courseId}/pages/${canvasPageId}`;
+  //   const body = {
+  //     wiki_page: {
+  //       title: localCoursePage.name,
+  //       body: localCoursePage.getBodyHtml(),
+  //     },
+  //   };
+
+  //   await webRequestor.put({
+  //     url,
+  //     body,
+  //   });
+  // },
+
+  // async delete(courseId: number, canvasPageId: number): Promise<void> {
+  //   console.log(`Deleting page from canvas ${canvasPageId}`);
+  //   const url = `courses/${courseId}/pages/${canvasPageId}`;
+  //   const response = await webRequestor.delete({ url });
+
+  //   if (!response.isSuccessful) {
+  //     console.error(url);
+  //     throw new Error("Failed to delete canvas course page");
+  //   }
+  // },
+};

nextjs/src/services/canvas/canvasService.ts

@@ -29,13 +29,6 @@ export const canvasService = {
   async getCourse(courseId: number): Promise<CanvasCourseModel> {
     const url = `courses/${courseId}`;
     const { data, response } = await webRequestor.get<CanvasCourseModel>(url);
-
-    if (!data) {
-      console.error((await response?.text()) ?? "");
-      console.error(response?.url ?? "");
-      throw new Error("Error getting course from Canvas");
-    }
-
     return data;
   },
 

nextjs/src/services/canvas/canvasServiceUtils.ts

@@ -1,11 +1,16 @@
 // services/canvasServiceUtils.ts
 
+import { AxiosResponseHeaders, RawAxiosResponseHeaders } from "axios";
 import { webRequestor } from "./webRequestor";
 
-const BASE_URL = "https://snow.instructure.com/api/v1/";
+const getNextUrl = (
+  headers: AxiosResponseHeaders | RawAxiosResponseHeaders
+): string | undefined => {
+  const linkHeader: string | undefined =
+    typeof headers.get === "function"
+      ? (headers.get("link") as string)
+      : ((headers as RawAxiosResponseHeaders)["link"] as string);
 
-const getNextUrl = (headers: Headers): string | undefined => {
-  const linkHeader = headers.get("Link");
   if (!linkHeader) return undefined;
 
   const links = linkHeader.split(",").map((link) => link.trim());
@@ -14,33 +19,24 @@ const getNextUrl = (headers: Headers): string | undefined => {
   if (!nextLink) return undefined;
 
   const nextUrl = nextLink.split(";")[0].trim().slice(1, -1);
-  return nextUrl.replace(BASE_URL, "").trim();
+  return nextUrl;
 };
 
 export const canvasServiceUtils = {
   async paginatedRequest<T>(request: { url: string }): Promise<T[]> {
     var requestCount = 1;
-    const url = new URL(request.url!, BASE_URL);
+    const url = new URL(request.url);
     url.searchParams.set("per_page", "100");
 
     const { data: firstData, response: firstResponse } =
       await webRequestor.get<T>(url.toString());
 
-    if (!firstResponse.ok) {
-      console.error(
-        "error in response",
-        firstResponse.statusText,
-        firstResponse.body
-      );
-      throw new Error("error in response");
-    }
-
     var returnData: T[] = firstData ? [firstData] : [];
     var nextUrl = getNextUrl(firstResponse.headers);
 
     while (nextUrl) {
       requestCount += 1;
-      const {data, response} = await webRequestor.get<T>(nextUrl);
+      const { data, response } = await webRequestor.get<T>(nextUrl);
       if (data) {
         returnData = [...returnData, data];
       }

nextjs/src/services/canvas/webRequestor.ts

@@ -1,11 +1,12 @@
+import { axiosClient } from "../axiosUtils";
+
 type FetchOptions = Omit<RequestInit, "method">;
 
-const token = process.env.CANVAS_TOKEN;
+const token = process.env.NEXT_PUBLIC_CANVAS_TOKEN;
 if (!token) {
   throw new Error("CANVAS_TOKEN not in environment");
 }
 
-const baseUrl = `${process.env.CANVAS_URL}/api/v1/`;
 const rateLimitRetryCount = 6;
 const rateLimitSleepInterval = 1000;
 
@@ -112,27 +113,21 @@ const recursiveDelete = async (
 };
 export const webRequestor = {
   getMany: async <T>(url: string, options: FetchOptions = {}) => {
-    const response = await fetch(url, {
-      ...options,
-      method: "GET",
+    const response = await axiosClient.get<T[]>(url, {
       headers: {
-        ...options.headers,
         Authorization: `Bearer ${token}`,
       },
     });
-    return { data: await deserialize<T[]>(response), response };
+    return { data: response.data, response };
   },
 
-  get: async <T>(url: string, options: FetchOptions = {}) => {
-    const response = await fetch(url, {
-      ...options,
-      method: "GET",
+  get: async <T>(url: string) => {
+    const response = await axiosClient.get<T>(url, {
       headers: {
-        ...options.headers,
         Authorization: `Bearer ${token}`,
       },
     });
-    return { data: await deserialize<T>(response), response };
+    return { data: response.data, response };
   },
 
   post: async (url: string, body: any) => {