@robertying/thu-learn-lib 4.1.0 → 5.1.0

package/src/auth.ts

@@ -34,6 +34,7 @@ export async function getRoamingTicket(
     } as ApiError;
   }
 
+  let page: string;
   try {
     const loginForm = await s.rawFetch(URLS.ID_LOGIN());
     const body = $(await loginForm.text());
@@ -52,16 +53,27 @@ export async function getRoamingTicket(
       body: formData,
     });
 
-    const anchor = $(await checkResponse.text())('a');
-    const redirectUrl = anchor.attr('href') as string;
-    const ticket = redirectUrl.split('=').slice(-1)[0];
-    return ticket;
+    if (!checkResponse.ok) {
+      throw { code: checkResponse.status, text: checkResponse.statusText };
+    }
+    page = await checkResponse.text();
   } catch (err) {
     throw {
       reason: FailReason.ERROR_FETCH_FROM_ID,
       extra: err,
     } as ApiError;
   }
+
+  // id.tsinghua.edu.cn answers with a link to the roaming URL (with the ticket), or with the form and an error
+  const body = $(page);
+  const redirectUrl = body('a').attr('href');
+  if (!redirectUrl) {
+    throw {
+      reason: FailReason.BAD_CREDENTIAL,
+      extra: body.root().text().replace(/\s+/g, ' ').trim().slice(0, 200),
+    } as ApiError;
+  }
+  return redirectUrl.split('=').slice(-1)[0];
 }
 
 /** login is necessary if you do not provide a `CredentialProvider` */
@@ -115,7 +127,8 @@ export async function login(
   if (langMatches.length !== 0) s.lang = langMatches[0][1] === 'en' ? Language.EN : Language.ZH;
 }
 
-/**  logout (to make everyone happy) */
+/**  logout (to make everyone happy); the CSRF token is cleared, so the next request logs in again */
 export async function logout(s: Session): Promise<void> {
   await s.rawFetch(URLS.LEARN_LOGOUT(), { method: 'POST' });
+  s.csrfToken = '';
 }

package/src/calendar.ts

@@ -1,7 +1,7 @@
 // Course calendar from the registrar (academic.tsinghua.edu.cn).
 
 import type { Session } from './request.ts';
-import type { CalendarEvent, CalendarOptions, CalendarRange, CalendarResult } from './types.ts';
+import type { ApiError, CalendarEvent, CalendarOptions, CalendarRange, CalendarResult } from './types.ts';
 import { FailReason } from './types.ts';
 import * as URLS from './urls.ts';
 import { JSONP_EXTRACTOR_NAME, extractJSONPResult } from './utils.ts';
@@ -11,11 +11,16 @@ export const CALENDAR_WINDOW_DAYS = 28;
 
 const DAY_MS = 24 * 60 * 60 * 1000;
 
+/** after this many windows in a row time out, `getCalendar` gives up on the rest (they go to `failedRanges`) */
+const MAX_CONSECUTIVE_TIMEOUTS = 2;
+
+const isTimeout = (err: unknown) => (err as ApiError | undefined)?.reason === FailReason.REQUEST_TIMEOUT;
+
 const parseDate = (date: string): number => {
   const match = /^(\d{4})(\d{2})(\d{2})$/.exec(date);
   const time = match ? Date.UTC(Number(match[1]), Number(match[2]) - 1, Number(match[3])) : NaN;
   if (Number.isNaN(time) || formatDate(time) !== date) {
-    throw { reason: FailReason.INVALID_RESPONSE, extra: `invalid date ${date}, expected yyyymmdd` };
+    throw new RangeError(`invalid date ${date}, expected yyyymmdd`);
   }
   return time;
 };
@@ -60,10 +65,12 @@ async function fetchWindow(s: Session, range: CalendarRange, graduate: boolean):
 /**
  * Get calendar items during the specified period (in yyyymmdd format, both inclusive).
  *
- * Ranges longer than `CALENDAR_WINDOW_DAYS` are fetched in consecutive windows (one at a time, each retried once) and
- * merged in date order. Windows that still fail are listed in `failedRanges`, so callers can show partial data and
- * retry only those. If every window fails, this rejects with the last error instead (usually
- * `FailReason.INVALID_RESPONSE`). The result might be empty if the period is too far away from now.
+ * Ranges longer than `CALENDAR_WINDOW_DAYS` are fetched in consecutive windows (one at a time, each retried once
+ * unless it timed out) and merged in date order. Windows that still fail are listed in `failedRanges`, so callers can
+ * show partial data and retry only those; after two windows in a row time out, the rest are listed there without a
+ * request. If every window fails, this rejects with the last error instead (usually `FailReason.INVALID_RESPONSE`).
+ * The result might be empty if the period is too far away from now. Throws a `RangeError` for a date that is not a
+ * valid yyyymmdd.
  */
 export async function getCalendar(
   s: Session,
@@ -75,12 +82,10 @@ export async function getCalendar(
   const ranges = splitCalendarRange(startDate, endDate);
   if (ranges.length === 0) return { events: [], failedRanges: [] };
 
-  const ticketResponse = await s.fetchWithToken(URLS.REGISTRAR_TICKET(), {
+  let ticket = await s.fetchTextWithToken(URLS.REGISTRAR_TICKET(), {
     method: 'POST',
     body: URLS.REGISTRAR_TICKET_FORM_DATA(),
   });
-
-  let ticket = await ticketResponse.text();
   ticket = ticket.substring(1, ticket.length - 1);
 
   await s.fetch(URLS.REGISTRAR_AUTH(ticket));
@@ -88,12 +93,25 @@ export async function getCalendar(
   const events: CalendarEvent[] = [];
   const failedRanges: CalendarRange[] = [];
   let lastError: unknown;
+  let timeouts = 0;
   for (const range of ranges) {
+    // after this many timed-out windows in a row the registrar is taken as down, and the rest are not tried
+    if (timeouts >= MAX_CONSECUTIVE_TIMEOUTS) {
+      failedRanges.push(range);
+      continue;
+    }
     try {
-      events.push(...(await fetchWindow(s, range, graduate).catch(() => fetchWindow(s, range, graduate))));
+      // a timed-out window is not retried: the registrar is slow, not flaky, and each try takes `requestTimeout`
+      events.push(
+        ...(await fetchWindow(s, range, graduate).catch((err: unknown) =>
+          isTimeout(err) ? Promise.reject(err) : fetchWindow(s, range, graduate),
+        )),
+      );
+      timeouts = 0;
     } catch (e) {
       lastError = e;
       failedRanges.push(range);
+      timeouts = isTimeout(e) ? timeouts + 1 : 0;
     }
   }
 

package/src/contents.ts

@@ -1,7 +1,7 @@
 // One kind of content for many courses at once.
 
 import type { Session } from './request.ts';
-import type { ContentTypeMap, CourseContent } from './types.ts';
+import type { AllContentsOptions, AllContentsResult, ContentTypeMap, CourseContent } from './types.ts';
 import { ContentType, CourseType, FailReason } from './types.ts';
 import { getAnsweredQuestionList, getDiscussionList } from './discussions.ts';
 import { getFileList } from './files.ts';
@@ -11,29 +11,42 @@ import { getQuestionnaireList } from './questionnaires.ts';
 
 /**
  * Get certain type of content of all specified courses.
- * It actually wraps around other `getXXX` functions. You can ignore the failure caused by certain courses.
+ * It wraps around the `getXXX` list functions; one course failing doesn't fail the others: its error is in `errors`.
  */
 export async function getAllContents<T extends ContentType>(
   s: Session,
   courseIDs: string[],
   type: T,
-  courseType: CourseType = CourseType.STUDENT,
-  allowFailure = false,
-) {
-  const fetchContentForCourse = (id: string) => {
+  options: AllContentsOptions<T> = {},
+): Promise<AllContentsResult<T>> {
+  const courseType = options.courseType ?? CourseType.STUDENT;
+  const fetchContentForCourse = (id: string): Promise<ContentTypeMap[T][]> => {
     switch (type) {
       case ContentType.NOTIFICATION:
-        return getNotificationList(s, id, courseType) as Promise<ContentTypeMap[T][]>;
+        return getNotificationList(s, id, courseType, {
+          attachments: (options as AllContentsOptions<ContentType.NOTIFICATION>).details,
+        }) as Promise<ContentTypeMap[T][]>;
       case ContentType.FILE:
         return getFileList(s, id, courseType) as Promise<ContentTypeMap[T][]>;
       case ContentType.HOMEWORK:
-        return getHomeworkList(s, id) as Promise<ContentTypeMap[T][]>;
+        if (courseType === CourseType.TEACHER) {
+          // the teacher list has another shape (`HomeworkTA`); use `getHomeworkList(id, CourseType.TEACHER)`
+          return Promise.reject({
+            reason: FailReason.NOT_IMPLEMENTED,
+            extra: 'homework of a teacher course; use getHomeworkList(courseID, CourseType.TEACHER)',
+          });
+        }
+        return getHomeworkList(s, id, CourseType.STUDENT, {
+          details: (options as AllContentsOptions<ContentType.HOMEWORK>).details,
+        }) as Promise<ContentTypeMap[T][]>;
       case ContentType.DISCUSSION:
         return getDiscussionList(s, id, courseType) as Promise<ContentTypeMap[T][]>;
       case ContentType.QUESTION:
         return getAnsweredQuestionList(s, id, courseType) as Promise<ContentTypeMap[T][]>;
       case ContentType.QUESTIONNAIRE:
-        return getQuestionnaireList(s, id) as Promise<ContentTypeMap[T][]>;
+        return getQuestionnaireList(s, id, {
+          details: (options as AllContentsOptions<ContentType.QUESTIONNAIRE>).details,
+        }) as Promise<ContentTypeMap[T][]>;
       default:
         return Promise.reject({
           reason: FailReason.NOT_IMPLEMENTED,
@@ -43,25 +56,17 @@ export async function getAllContents<T extends ContentType>(
   };
 
   const contents: CourseContent<T> = {};
+  const errors: AllContentsResult<T>['errors'] = {};
 
-  const results = await Promise.allSettled(
+  await Promise.all(
     courseIDs.map(async (id) => {
-      contents[id] = await fetchContentForCourse(id);
+      try {
+        contents[id] = await fetchContentForCourse(id);
+      } catch (err) {
+        errors[id] = err;
+      }
     }),
   );
 
-  if (!allowFailure) {
-    for (const r of results) {
-      if (r.status === 'rejected') {
-        return Promise.reject({
-          reason: FailReason.INVALID_RESPONSE,
-          extra: {
-            reason: r.reason,
-          },
-        });
-      }
-    }
-  }
-
-  return contents;
+  return { contents, errors };
 }

package/src/courses.ts

@@ -1,13 +1,13 @@
 // Semesters and courses.
 
 import type { Session } from './request.ts';
-import type { CourseInfo, SemesterInfo } from './types.ts';
+import type { ApiError, CourseInfo, CourseListOptions, SemesterInfo } from './types.ts';
 import { CourseType, FailReason } from './types.ts';
 import * as URLS from './urls.ts';
 import { decodeHTML, parseSemesterType } from './utils.ts';
 
 export async function getSemesterIdList(s: Session): Promise<string[]> {
-  const json = await (await s.fetchWithToken(URLS.LEARN_SEMESTER_LIST())).json();
+  const json = await s.fetchJsonWithToken(URLS.LEARN_SEMESTER_LIST());
   if (!Array.isArray(json)) {
     return Promise.reject({
       reason: FailReason.INVALID_RESPONSE,
@@ -20,7 +20,7 @@ export async function getSemesterIdList(s: Session): Promise<string[]> {
 }
 
 export async function getCurrentSemester(s: Session): Promise<SemesterInfo> {
-  const json = await (await s.fetchWithToken(URLS.LEARN_CURRENT_SEMESTER())).json();
+  const json = await s.fetchJsonWithToken(URLS.LEARN_CURRENT_SEMESTER());
   if (json.message !== 'success') {
     return Promise.reject({
       reason: FailReason.INVALID_RESPONSE,
@@ -38,14 +38,15 @@ export async function getCurrentSemester(s: Session): Promise<SemesterInfo> {
   };
 }
 
-/** get all courses in the specified semester */
+/** get all courses in the specified semester; time and location only with `options.timeAndLocation` */
 export async function getCourseList(
   s: Session,
   semesterID: string,
   courseType: CourseType = CourseType.STUDENT,
   lang = s.lang,
+  options: CourseListOptions = {},
 ): Promise<CourseInfo[]> {
-  const json = await (await s.fetchWithToken(URLS.LEARN_COURSE_LIST(semesterID, courseType, lang))).json();
+  const json = await s.fetchJsonWithToken(URLS.LEARN_COURSE_LIST(semesterID, courseType, lang));
   if (json.message !== 'success' || !Array.isArray(json.resultList)) {
     return Promise.reject({
       reason: FailReason.INVALID_RESPONSE,
@@ -56,11 +57,14 @@ export async function getCourseList(
 
   return Promise.all(
     result.map(async (c) => {
-      let timeAndLocation: string[] = [];
-      try {
-        // see https://github.com/Harry-Chen/Learn-Helper/issues/145
-        timeAndLocation = await (await s.fetchWithToken(URLS.LEARN_COURSE_TIME_LOCATION(c.wlkcid))).json();
-      } catch (e) {}
+      let timeAndLocation: string[] | undefined;
+      if (options.timeAndLocation) {
+        try {
+          timeAndLocation = await getCourseTimeAndLocation(s, c.wlkcid);
+        } catch {
+          timeAndLocation = [];
+        }
+      }
       return {
         id: c.wlkcid,
         name: decodeHTML(c.zywkcm),
@@ -78,16 +82,24 @@ export async function getCourseList(
   );
 }
 
+/** get the time and location of one course (1 request) */
+export async function getCourseTimeAndLocation(s: Session, courseID: string): Promise<string[]> {
+  // see https://github.com/Harry-Chen/Learn-Helper/issues/145
+  const json = await s.fetchJsonWithToken(URLS.LEARN_COURSE_TIME_LOCATION(courseID));
+  if (!Array.isArray(json)) {
+    throw { reason: FailReason.INVALID_RESPONSE, extra: json } as ApiError;
+  }
+  return json as string[];
+}
+
 export async function sortCourses(s: Session, courseIDs: string[]): Promise<void> {
-  const json = await (
-    await s.fetchWithToken(URLS.LEARN_SORT_COURSES, {
-      method: 'POST',
-      body: JSON.stringify(courseIDs.map((id, index) => ({ wlkcid: id, xh: index + 1 }))),
-      headers: {
-        'Content-Type': 'application/json',
-      },
-    })
-  ).json();
+  const json = await s.fetchJsonWithToken(URLS.LEARN_SORT_COURSES, {
+    method: 'POST',
+    body: JSON.stringify(courseIDs.map((id, index) => ({ wlkcid: id, xh: index + 1 }))),
+    headers: {
+      'Content-Type': 'application/json',
+    },
+  });
   if (json.result !== 'success') {
     return Promise.reject({
       reason: FailReason.OPERATION_FAILED,

package/src/discussions.ts

@@ -15,7 +15,7 @@ export async function getDiscussionList(
   courseID: string,
   courseType: CourseType = CourseType.STUDENT,
 ): Promise<Discussion[]> {
-  const json = await (await s.fetchWithToken(URLS.LEARN_DISCUSSION_LIST(courseID, courseType))).json();
+  const json = await s.fetchJsonWithToken(URLS.LEARN_DISCUSSION_LIST(courseID, courseType));
   if (json.result !== 'success') {
     return Promise.reject({
       reason: FailReason.INVALID_RESPONSE,
@@ -44,7 +44,7 @@ export async function getAnsweredQuestionList(
   courseID: string,
   courseType: CourseType = CourseType.STUDENT,
 ): Promise<Question[]> {
-  const json = await (await s.fetchWithToken(URLS.LEARN_QUESTION_LIST_ANSWERED(courseID, courseType))).json();
+  const json = await s.fetchJsonWithToken(URLS.LEARN_QUESTION_LIST_ANSWERED(courseID, courseType));
   if (json.result !== 'success') {
     return Promise.reject({
       reason: FailReason.INVALID_RESPONSE,

package/src/favorites.ts

@@ -11,7 +11,7 @@ import { CONTENT_TYPE_MAP_REVERSE, decodeHTML } from './utils.ts';
  * Add an item to favorites. (收藏)
  */
 export async function addToFavorites(s: Session, type: ContentType, id: string): Promise<void> {
-  const json = await (await s.fetchWithToken(URLS.LEARN_FAVORITE_ADD(type, id))).json();
+  const json = await s.fetchJsonWithToken(URLS.LEARN_FAVORITE_ADD(type, id));
   if (json.result !== 'success' || !json.msg?.endsWith?.('成功')) {
     return Promise.reject({
       reason: FailReason.OPERATION_FAILED,
@@ -24,7 +24,7 @@ export async function addToFavorites(s: Session, type: ContentType, id: string):
  * Remove an item from favorites. (取消收藏)
  */
 export async function removeFromFavorites(s: Session, id: string): Promise<void> {
-  const json = await (await s.fetchWithToken(URLS.LEARN_FAVORITE_REMOVE(id))).json();
+  const json = await s.fetchJsonWithToken(URLS.LEARN_FAVORITE_REMOVE(id));
   if (json.result !== 'success' || !json.msg?.endsWith?.('成功')) {
     return Promise.reject({
       reason: FailReason.OPERATION_FAILED,
@@ -38,12 +38,10 @@ export async function removeFromFavorites(s: Session, id: string): Promise<void>
  * If `courseID` or `type` is specified, only return favorites of that course or type.
  */
 export async function getFavorites(s: Session, courseID?: string, type?: ContentType): Promise<FavoriteItem[]> {
-  const json = await (
-    await s.fetchWithToken(URLS.LEARN_FAVORITE_LIST(type), {
-      method: 'POST',
-      body: URLS.LEARN_PAGE_LIST_FORM_DATA(courseID),
-    })
-  ).json();
+  const json = await s.fetchJsonWithToken(URLS.LEARN_FAVORITE_LIST(type), {
+    method: 'POST',
+    body: URLS.LEARN_PAGE_LIST_FORM_DATA(courseID),
+  });
   if (json.result !== 'success') {
     return Promise.reject({
       reason: FailReason.INVALID_RESPONSE,
@@ -78,12 +76,10 @@ export async function getFavorites(s: Session, courseID?: string, type?: Content
  * Pin a favorite item. (置顶)
  */
 export async function pinFavoriteItem(s: Session, id: string): Promise<void> {
-  const json = await (
-    await s.fetchWithToken(URLS.LEARN_FAVORITE_PIN, {
-      method: 'POST',
-      body: URLS.LEARN_FAVORITE_PIN_UNPIN_FORM_DATA(id),
-    })
-  ).json();
+  const json = await s.fetchJsonWithToken(URLS.LEARN_FAVORITE_PIN, {
+    method: 'POST',
+    body: URLS.LEARN_FAVORITE_PIN_UNPIN_FORM_DATA(id),
+  });
   if (json.result !== 'success') {
     return Promise.reject({
       reason: FailReason.OPERATION_FAILED,
@@ -96,12 +92,10 @@ export async function pinFavoriteItem(s: Session, id: string): Promise<void> {
  * Unpin a favorite item. (取消置顶)
  */
 export async function unpinFavoriteItem(s: Session, id: string): Promise<void> {
-  const json = await (
-    await s.fetchWithToken(URLS.LEARN_FAVORITE_UNPIN, {
-      method: 'POST',
-      body: URLS.LEARN_FAVORITE_PIN_UNPIN_FORM_DATA(id),
-    })
-  ).json();
+  const json = await s.fetchJsonWithToken(URLS.LEARN_FAVORITE_UNPIN, {
+    method: 'POST',
+    body: URLS.LEARN_FAVORITE_PIN_UNPIN_FORM_DATA(id),
+  });
   if (json.result !== 'success') {
     return Promise.reject({
       reason: FailReason.OPERATION_FAILED,
@@ -115,12 +109,10 @@ export async function unpinFavoriteItem(s: Session, id: string): Promise<void> {
  * Set an empty string to remove the comment.
  */
 export async function setComment(s: Session, type: ContentType, id: string, content: string): Promise<void> {
-  const json = await (
-    await s.fetchWithToken(URLS.LEARN_COMMENT_SET, {
-      method: 'POST',
-      body: URLS.LEARN_COMMENT_SET_FORM_DATA(type, id, content),
-    })
-  ).json();
+  const json = await s.fetchJsonWithToken(URLS.LEARN_COMMENT_SET, {
+    method: 'POST',
+    body: URLS.LEARN_COMMENT_SET_FORM_DATA(type, id, content),
+  });
   if (json.result !== 'success' || !json.msg?.endsWith?.('成功')) {
     return Promise.reject({
       reason: FailReason.OPERATION_FAILED,
@@ -134,12 +126,10 @@ export async function setComment(s: Session, type: ContentType, id: string, cont
  * If `courseID` or `type` is specified, only return favorites of that course or type.
  */
 export async function getComments(s: Session, courseID?: string, type?: ContentType): Promise<CommentItem[]> {
-  const json = await (
-    await s.fetchWithToken(URLS.LEARN_COMMENT_LIST(type), {
-      method: 'POST',
-      body: URLS.LEARN_PAGE_LIST_FORM_DATA(courseID),
-    })
-  ).json();
+  const json = await s.fetchJsonWithToken(URLS.LEARN_COMMENT_LIST(type), {
+    method: 'POST',
+    body: URLS.LEARN_PAGE_LIST_FORM_DATA(courseID),
+  });
   if (json.result !== 'success') {
     return Promise.reject({
       reason: FailReason.INVALID_RESPONSE,

package/src/files.ts

@@ -6,13 +6,13 @@ import { ContentType, CourseType, FailReason } from './types.ts';
 import * as URLS from './urls.ts';
 import { decodeHTML, formatFileSize } from './utils.ts';
 
-/** Get all files （课程文件） of the specified course. */
+/** Get all files （课程文件） of the specified course; `category` is left out if the categories can't be fetched. */
 export async function getFileList(
   s: Session,
   courseID: string,
   courseType: CourseType = CourseType.STUDENT,
 ): Promise<File[]> {
-  const json = await (await s.fetchWithToken(URLS.LEARN_FILE_LIST(courseID, courseType))).json();
+  const json = await s.fetchJsonWithToken(URLS.LEARN_FILE_LIST(courseID, courseType));
   if (json.result !== 'success') {
     return Promise.reject({
       reason: FailReason.INVALID_RESPONSE,
@@ -29,7 +29,9 @@ export async function getFileList(
     result = json.object;
   }
 
-  const categories = new Map((await getFileCategoryList(s, courseID, courseType)).map((c) => [c.id, c]));
+  // categories only fill `category`; don't fail the whole list when they can't be fetched
+  const categoryList = await getFileCategoryList(s, courseID, courseType).catch(() => []);
+  const categories = new Map(categoryList.map((c) => [c.id, c]));
 
   return result.map((f) => {
     const title = decodeHTML(f.bt);
@@ -71,7 +73,7 @@ export async function getFileCategoryList(
   courseID: string,
   courseType: CourseType = CourseType.STUDENT,
 ): Promise<FileCategory[]> {
-  const json = await (await s.fetchWithToken(URLS.LEARN_FILE_CATEGORY_LIST(courseID, courseType))).json();
+  const json = await s.fetchJsonWithToken(URLS.LEARN_FILE_CATEGORY_LIST(courseID, courseType));
   if (json.result !== 'success') {
     return Promise.reject({
       reason: FailReason.INVALID_RESPONSE,
@@ -102,7 +104,7 @@ export async function getFileListByCategory(
   courseType: CourseType = CourseType.STUDENT,
 ): Promise<File[]> {
   if (courseType === CourseType.STUDENT) {
-    const json = await (await s.fetchWithToken(URLS.LEARN_FILE_LIST_BY_CATEGORY_STUDENT(courseID, categoryId))).json();
+    const json = await s.fetchJsonWithToken(URLS.LEARN_FILE_LIST_BY_CATEGORY_STUDENT(courseID, categoryId));
     if (json.result !== 'success') {
       return Promise.reject({
         reason: FailReason.INVALID_RESPONSE,
@@ -147,12 +149,10 @@ export async function getFileListByCategory(
       } satisfies File;
     });
   } else {
-    const json = await (
-      await s.fetchWithToken(URLS.LEARN_FILE_LIST_BY_CATEGORY_TEACHER, {
-        method: 'POST',
-        body: URLS.LEARN_FILE_LIST_BY_CATEGORY_TEACHER_FORM_DATA(courseID, categoryId),
-      })
-    ).json();
+    const json = await s.fetchJsonWithToken(URLS.LEARN_FILE_LIST_BY_CATEGORY_TEACHER, {
+      method: 'POST',
+      body: URLS.LEARN_FILE_LIST_BY_CATEGORY_TEACHER_FORM_DATA(courseID, categoryId),
+    });
     if (json.result !== 'success') {
       return Promise.reject({
         reason: FailReason.INVALID_RESPONSE,
@@ -160,7 +160,7 @@ export async function getFileListByCategory(
       });
     }
 
-    const result = (json.object.aaData ?? []) as any[];
+    const result = (json.object?.aaData ?? []) as any[];
 
     return result.map((f) => {
       const title = decodeHTML(f.bt);