track-cli 3.1.0 → 4.0.0-rc0

package/esm/src/track/client.js

@@ -1,6 +1,6 @@
 import { VERSION } from "../meta.js";
 import { HttpStatus } from "../shared/mod.js";
-import { APIError, OtherError } from "../shared/errors.js";
+import { APIError } from "../shared/errors.js";
 // @ts-ignore: has no exported member
 import { CookieJar, fetch } from "node-fetch-cookies";
 import { ProxyAgent } from "proxy-agent";
@@ -8,8 +8,8 @@ export const FormType = {
     URLEncoded: "urlencoded",
     JSON: "json",
 };
-export class TrackClient {
-    constructor(scheme, hostname, basic, authData) {
+export class TrackClientBase {
+    constructor(baseUrl, basic, cookies, isUnauthorized) {
         Object.defineProperty(this, "baseUrl", {
             enumerable: true,
             configurable: true,
@@ -28,71 +28,34 @@ export class TrackClient {
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "authData", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "cookieExpired", {
+        Object.defineProperty(this, "agent", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: false
+            value: new ProxyAgent()
         });
-        Object.defineProperty(this, "agent", {
+        Object.defineProperty(this, "isUnauthorized", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: new ProxyAgent()
+            value: void 0
         });
-        this.baseUrl = `${scheme}://${hostname}`;
-        this.headers = {};
-        this.headers["X-Requested-With"] = "codecheck";
-        this.headers["User-Agent"] = `track-cli-${VERSION}`;
+        this.baseUrl = baseUrl;
+        this.headers = {
+            "X-Requested-With": "codecheck",
+            "User-Agent": `track-cli-${VERSION}`,
+        };
         if (basic) {
             this.headers["Authorization"] = `Basic ${btoa(`${basic.username}:${basic.password}`)}`;
         }
         this.cookies = new CookieJar();
-        this.authData = authData;
-    }
-    getCookies() {
-        const cookies = {};
-        for (const cookie of this.cookies.cookiesAll()) {
-            if (cookie.name && cookie.value) {
-                cookies[cookie.name] = cookie.value;
-            }
-        }
-        return cookies;
-    }
-    authCookieExpired() {
-        return this.cookieExpired;
-    }
-    static fromTrackConfig(config) {
-        const authData = {
-            examToken: config.examToken,
-            orgName: config.orgName,
-        };
-        const client = new TrackClient(config.scheme, config.host, config.basicAuth, authData);
-        if (config.cookies) {
-            for (const [name, value] of Object.entries(config.cookies)) {
-                client.cookies.addCookie(`${name}=${value}`, client.baseUrl);
-            }
-        }
-        return client;
-    }
-    async authenticate() {
-        this.cookies = new CookieJar();
-        if (this.authData) {
-            const authUrl = `${this.baseUrl}/${this.authData.orgName}/exams/${this.authData.examToken}`;
-            const res = await fetch(this.cookies, authUrl, {
-                headers: this.headers,
-                agent: this.agent,
-            });
-            if (!HttpStatus.isSuccess(res)) {
-                throw new OtherError(`Failed to authenticate: ${res.status}\n${await res.text()}`);
+        if (cookies) {
+            for (const [name, value] of Object.entries(cookies)) {
+                this.cookies.addCookie(`${name}=${value}`, baseUrl);
             }
         }
+        this.isUnauthorized = isUnauthorized ||
+            ((res) => res.status === HttpStatus.Unauthorized);
     }
     async _get(path, asText = false) {
         const url = `${this.baseUrl}${path}`;
@@ -100,12 +63,12 @@ export class TrackClient {
             method: "GET",
             headers: this.headers,
             agent: this.agent,
+            redirect: "manual",
         });
-        if (response1.status !== HttpStatus.Unauthorized) {
+        if (!this.isUnauthorized(response1)) {
             return await this._result(response1, asText);
         }
         await this.authenticate();
-        this.cookieExpired = true;
         const response2 = await fetch(this.cookies, url, {
             method: "GET",
             headers: this.headers,
@@ -134,12 +97,12 @@ export class TrackClient {
             headers: headers,
             body: bodyData,
             agent: this.agent,
+            redirect: "manual",
         });
-        if (response1.status !== HttpStatus.Unauthorized) {
+        if (!this.isUnauthorized(response1)) {
             return await this._result(response1);
         }
         await this.authenticate();
-        this.cookieExpired = true;
         const response2 = await fetch(this.cookies, url, {
             method: "POST",
             headers: headers,
@@ -169,12 +132,12 @@ export class TrackClient {
             headers: headers,
             body: bodyData,
             agent: this.agent,
+            redirect: "manual",
         });
-        if (response1.status !== HttpStatus.Unauthorized) {
+        if (!this.isUnauthorized(response1)) {
             return await this._result(response1);
         }
         await this.authenticate();
-        this.cookieExpired = true;
         const response2 = await fetch(this.cookies, url, {
             method: "PUT",
             headers: headers,
@@ -202,67 +165,13 @@ export class TrackClient {
             throw await APIError.fromResponse(response);
         }
     }
-    async getApplicantExamNoAuth(token) {
-        return await this._get(`/api/applicants/exams/${token}/min`);
-    }
-    async getExamSession(applicantExamId) {
-        return await this._get(`/api/applicants/exams/${applicantExamId}`);
-    }
-    async getProgrammingLanguages() {
-        return await this._get(`/api/enum/challenges/programminglanguages`);
-    }
-    async findProgrammingLanguage(programmingLanguage) {
-        return (await this.getProgrammingLanguages())
-            .find((pl, _) => pl.value === programmingLanguage);
-    }
-    async switchChallengeLanguage(applicantExamId, resultId, language) {
-        return await this._put(`/api/applicants/exams/${applicantExamId}/results/${resultId}/language`, FormType.URLEncoded, {
-            programmingLanguage: language,
-        });
-    }
-    async startChallenge(applicantExamId, resultId) {
-        return await this._put(`/api/applicants/exams/${applicantExamId}/results/${resultId}/start`, FormType.URLEncoded, {
-            takenBy: 3, // 3 = LocalMachine
-        });
-    }
-    async prepareChallenge(applicantExamId, challengeId) {
-        return await this._post(`/api/applicants/exams/${applicantExamId}/results`, FormType.URLEncoded, {
-            challengeId: challengeId,
-        });
-    }
-    async timeLeft(applicantExamId, resultId) {
-        return await this._get(`/api/applicants/exams/${applicantExamId}/results/${resultId}/timeleft`);
-    }
-    async getChallengeCodingContext(applicantExamId, resultId) {
-        return await this._get(`/api/applicants/exams/${applicantExamId}/results/${resultId}/context`);
-    }
-    async getPresignedUrls(applicantExamId, resultId, files) {
-        return await this._post(`/api/applicants/exams/${applicantExamId}/results/${resultId}/presigned`, FormType.JSON, {
-            files: files,
-        });
-    }
-    async orcaToken(url) {
-        return await this._get(url);
-    }
-    /**
-     * Temporary code to retrieve the Orca host.
-     * Will be able to get from CodingContext in the future.
-     */
-    async orcaHost() {
-        const asText = true;
-        const editorHtml = await this._get("/editor/1.0/coding", asText);
-        return (/data-orca-host="([^"]+)"/.exec(editorHtml) ||
-            ["", "track-prod-frontend.orca.run"])[1];
-    }
-    async saveFiles(applicantExamId, resultId, saveFilesRequest) {
-        return await this._put(`/api/applicants/exams/${applicantExamId}/results/${resultId}/save`, FormType.JSON, saveFilesRequest);
-    }
-    async updateEditorScore(applicantExamId, resultId, editorScore) {
-        return await this._put(`/api/applicants/exams/${applicantExamId}/results/${resultId}/editorScore`, FormType.URLEncoded, {
-            editorScore: editorScore,
-        });
-    }
-    async reset(applicantExamId, resultId) {
-        return await this._put(`/api/applicants/exams/${applicantExamId}/results/${resultId}/reset`, FormType.URLEncoded, {});
+    getCookies() {
+        const cookies = {};
+        for (const cookie of this.cookies.cookiesAll()) {
+            if (cookie.name && cookie.value) {
+                cookies[cookie.name] = cookie.value;
+            }
+        }
+        return cookies;
     }
 }

package/esm/src/track/test.d.ts

@@ -0,0 +1,32 @@
+import { TrackTestConfigPart } from "../shared/config.js";
+import { ChallengeResult, ChallengeSession, CodingContext, ProgrammingLanguage, ProgrammingLanguageInfo, SaveFilesRequest } from "../shared/types.js";
+import { BasicAuth, TrackClient, TrackClientBase } from "./client.js";
+export declare class TestClient extends TrackClientBase implements TrackClient {
+    private orgName;
+    private token;
+    private challengeId;
+    private applicantExamId;
+    private resultId;
+    constructor(baseUrl: string, orgName: string, token: string, challengeId: number, basic?: BasicAuth, cookies?: Record<string, string>);
+    config(): TrackTestConfigPart;
+    authenticate(): Promise<void>;
+    startChallengeSession(): Promise<ChallengeSession>;
+    private getApplicantExamNoAuth;
+    private ensureExamInProgress;
+    private getExamSession;
+    private getChallengeFromExamSession;
+    languages(): Promise<ProgrammingLanguageInfo[]>;
+    start(): Promise<ChallengeResult>;
+    prepare(): Promise<ChallengeResult>;
+    updateLanguage(language: ProgrammingLanguage): Promise<void>;
+    timeLeft(): Promise<number>;
+    context(): Promise<CodingContext>;
+    presigned(files: string[]): Promise<{
+        [name: string]: string;
+    }>;
+    orcaHost(): Promise<string>;
+    orcaToken(context: CodingContext): Promise<string>;
+    saveFiles(files: SaveFilesRequest): Promise<void>;
+    updateEditorScore(score: number): Promise<void>;
+    reset(): Promise<void>;
+}

package/esm/src/track/test.js

@@ -0,0 +1,184 @@
+import { ExamCanceled, ExamExpired, ExamSubmitted, ExamUnread, InvalidChallengeId, OtherError, } from "../shared/errors.js";
+import { HttpStatus } from "../shared/mod.js";
+import { ChallengeStyle, } from "../shared/types.js";
+import { FormType, TrackClientBase, } from "./client.js";
+// @ts-ignore: has no exported member
+import { CookieJar, fetch } from "node-fetch-cookies";
+export class TestClient extends TrackClientBase {
+    constructor(baseUrl, orgName, token, challengeId, basic, cookies) {
+        super(baseUrl, basic, cookies);
+        Object.defineProperty(this, "orgName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "token", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "challengeId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "applicantExamId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "resultId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        this.orgName = orgName;
+        this.token = token;
+        this.challengeId = challengeId;
+    }
+    config() {
+        return {
+            challengeId: this.challengeId,
+            applicantExamId: this.applicantExamId,
+            challengeResultId: this.resultId,
+        };
+    }
+    async authenticate() {
+        this.cookies = new CookieJar();
+        const authUrl = `${this.baseUrl}/${this.orgName}/exams/${this.token}`;
+        const res = await fetch(this.cookies, authUrl, {
+            headers: this.headers,
+            agent: this.agent,
+        });
+        if (!HttpStatus.isSuccess(res)) {
+            throw new OtherError(`Failed to authenticate: ${res.status}\n${await res.text()}`);
+        }
+    }
+    async startChallengeSession() {
+        const applicantExam = await this.getApplicantExamNoAuth();
+        const webUrl = `${this.baseUrl}/${this.orgName}/exams/${this.token}`;
+        this.ensureExamInProgress(applicantExam.status, webUrl);
+        const examSession = await this.getExamSession(applicantExam.id);
+        const result = examSession.results.find((r) => r.challengeId === this.challengeId);
+        const challenge = this.getChallengeFromExamSession(examSession, result);
+        if (!challenge) {
+            throw new InvalidChallengeId(this.challengeId);
+        }
+        this.applicantExamId = applicantExam.id;
+        this.resultId = result?.id || 0;
+        return challenge;
+    }
+    async getApplicantExamNoAuth() {
+        return await this._get(`/api/applicants/exams/${this.token}/min`);
+    }
+    ensureExamInProgress(status, webUrlRedirect) {
+        switch (status) {
+            case ApplicantExamStatus.Submitted:
+            case ApplicantExamStatus.Reviewed:
+                throw new ExamSubmitted();
+            case ApplicantExamStatus.Expired:
+                throw new ExamExpired();
+            case ApplicantExamStatus.Canceled:
+                throw new ExamCanceled();
+            case ApplicantExamStatus.Unread:
+                throw new ExamUnread(webUrlRedirect);
+            case ApplicantExamStatus.InProgress:
+                return;
+        }
+    }
+    async getExamSession(applicantExamId) {
+        return await this._get(`/api/applicants/exams/${applicantExamId}`);
+    }
+    getChallengeFromExamSession(examSession, result) {
+        return examSession.challengesSets
+            .flatMap((s) => s.challenges)
+            .map((esc) => toChallengeSession(esc, result))
+            .find((c) => c.challengeId === this.challengeId &&
+            (c.style === ChallengeStyle.Development ||
+                c.style === ChallengeStyle.Algorithm));
+    }
+    async languages() {
+        return (await this._get(`/api/enum/challenges/programminglanguages`))
+            .map(toProgrammingLanguageInfo);
+    }
+    async start() {
+        return await this._put(`/api/applicants/exams/${this.applicantExamId}/results/${this.resultId}/start`, FormType.URLEncoded, {
+            takenBy: 3, // 3 = LocalMachine
+        });
+    }
+    async prepare() {
+        return await this._post(`/api/applicants/exams/${this.applicantExamId}/results`, FormType.URLEncoded, {
+            challengeId: this.challengeId,
+        });
+    }
+    async updateLanguage(language) {
+        return await this._put(`/api/applicants/exams/${this.applicantExamId}/results/${this.resultId}/language`, FormType.URLEncoded, {
+            programmingLanguage: language,
+        }); // ChallengeResult
+    }
+    async timeLeft() {
+        return await this._get(`/api/applicants/exams/${this.applicantExamId}/results/${this.resultId}/timeleft`);
+    }
+    async context() {
+        return await this._get(`/api/applicants/exams/${this.applicantExamId}/results/${this.resultId}/context`);
+    }
+    async presigned(files) {
+        return await this._post(`/api/applicants/exams/${this.applicantExamId}/results/${this.resultId}/presigned`, FormType.JSON, {
+            files: files,
+        });
+    }
+    async orcaHost() {
+        const asText = true;
+        const editorHtml = await this._get("/editor/1.0/coding", asText);
+        return (/data-orca-host="([^"]+)"/.exec(editorHtml) ||
+            ["", "track-prod-frontend.orca.run"])[1];
+    }
+    async orcaToken(context) {
+        return await this._get(context.urlForOrcaToken);
+    }
+    async saveFiles(files) {
+        return await this._put(`/api/applicants/exams/${this.applicantExamId}/results/${this.resultId}/save`, FormType.JSON, files);
+    }
+    async updateEditorScore(score) {
+        return await this._put(`/api/applicants/exams/${this.applicantExamId}/results/${this.resultId}/editorScore`, FormType.URLEncoded, {
+            editorScore: score,
+        });
+    }
+    async reset() {
+        return await this._put(`/api/applicants/exams/${this.applicantExamId}/results/${this.resultId}/reset`, FormType.URLEncoded, {});
+    }
+}
+const ApplicantExamStatus = {
+    Unread: 1,
+    InProgress: 2,
+    Submitted: 3,
+    Expired: 4,
+    Canceled: 5,
+    Reviewed: 6,
+};
+function toChallengeSession(esc, result) {
+    return {
+        challengeId: esc.id,
+        challengeVersionId: esc.challengeVersionId,
+        style: esc.style,
+        title: esc.title,
+        description: esc.description,
+        timeLimitMinutes: esc.timeLimitMinutes,
+        displayOrder: esc.displayOrder,
+        programmingLanguages: esc.programmingLanguages,
+        localCodingAllowed: esc.localExamEnabled,
+        openTestcases: esc.openTestcases,
+        result,
+    };
+}
+function toProgrammingLanguageInfo(pl) {
+    return {
+        value: pl.value,
+        name: pl.displayString,
+    };
+}

package/esm/src/track/training.d.ts

@@ -0,0 +1,29 @@
+import { TrackTrainingConfigPart } from "../shared/config.js";
+import { ChallengeResult, ChallengeSession, CodingContext, ProgrammingLanguage, ProgrammingLanguageInfo, SaveFilesRequest } from "../shared/types.js";
+import { BasicAuth, TrackClient, TrackClientBase } from "./client.js";
+export declare class TrainingClient extends TrackClientBase implements TrackClient {
+    private orgName;
+    private token;
+    private courseMaterialId;
+    private klassId;
+    private klassResultId;
+    constructor(baseUrl: string, orgName: string, token: string, courseMaterialId: number, klassId: number, klassResultId: number, basic?: BasicAuth, cookies?: Record<string, string>);
+    config(): TrackTrainingConfigPart;
+    authenticate(): Promise<void>;
+    startChallengeSession(): Promise<ChallengeSession>;
+    continueChallengeSession(): Promise<ChallengeSession>;
+    languages(): Promise<ProgrammingLanguageInfo[]>;
+    start(): Promise<ChallengeResult>;
+    prepare(): Promise<ChallengeResult>;
+    updateLanguage(language: ProgrammingLanguage): Promise<void>;
+    timeLeft(): Promise<number>;
+    context(): Promise<CodingContext>;
+    presigned(files: string[]): Promise<{
+        [name: string]: string;
+    }>;
+    orcaHost(): Promise<string>;
+    orcaToken(context: CodingContext): Promise<string>;
+    saveFiles(files: SaveFilesRequest): Promise<void>;
+    updateEditorScore(score: number): Promise<void>;
+    reset(): Promise<void>;
+}

package/esm/src/track/training.js

@@ -0,0 +1,149 @@
+import { OtherError } from "../shared/errors.js";
+import { HttpStatus } from "../shared/mod.js";
+import { FormType, TrackClientBase, } from "./client.js";
+// @ts-ignore: has no exported member
+import { CookieJar, fetch } from "node-fetch-cookies";
+export class TrainingClient extends TrackClientBase {
+    constructor(baseUrl, orgName, token, courseMaterialId, klassId, klassResultId, basic, cookies) {
+        super(baseUrl, basic, cookies, (res) => HttpStatus.isRedirect(res) || res.status === HttpStatus.Unauthorized);
+        Object.defineProperty(this, "orgName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "token", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "courseMaterialId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "klassId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "klassResultId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.orgName = orgName;
+        this.token = token;
+        this.courseMaterialId = courseMaterialId;
+        this.klassId = klassId;
+        this.klassResultId = klassResultId;
+    }
+    config() {
+        return {
+            courseMaterialId: this.courseMaterialId,
+            klassId: this.klassId,
+            klassResultId: this.klassResultId,
+        };
+    }
+    async authenticate() {
+        this.cookies = new CookieJar();
+        const authUrl = `${this.baseUrl}/${this.orgName}/train/${this.token}/challenges/${this.courseMaterialId}`;
+        const res = await fetch(this.cookies, authUrl, {
+            headers: this.headers,
+            agent: this.agent,
+        });
+        if (!HttpStatus.isSuccess(res)) {
+            throw new OtherError(`Failed to authenticate: ${res.status}\n${await res.text()}`);
+        }
+        const { klassId } = (await res.json()).result;
+        this.klassId = klassId;
+    }
+    async startChallengeSession() {
+        const trainingChallenge = await this._post(`/api/train/${this.klassId}/challenges/${this.courseMaterialId}`, FormType.JSON, {});
+        this.klassResultId = trainingChallenge.result.klassResultId;
+        return toChallengeSession(trainingChallenge);
+    }
+    continueChallengeSession() {
+        return this.startChallengeSession();
+    }
+    async languages() {
+        return (await this._get(`/cli/languages`))
+            .map(toProgrammingLanguageInfo);
+    }
+    async start() {
+        return await this._put(`/api/train/${this.klassId}/challenges/results/${this.klassResultId}/start`, FormType.JSON, {
+            takenBy: 3, // 3 = LocalMachine
+        });
+    }
+    prepare() {
+        throw new OtherError("Unsupported operation");
+    }
+    async updateLanguage(language) {
+        await this._put(`/api/train/${this.klassId}/challenges/results/${this.klassResultId}/lang`, FormType.JSON, {
+            lang: language,
+        });
+    }
+    async timeLeft() {
+        return await this._get(`/api/train/${this.klassId}/challenges/results/${this.klassResultId}/timeleft`);
+    }
+    async context() {
+        return await this._get(`/api/train/${this.klassId}/challenges/results/${this.klassResultId}/context`);
+    }
+    async presigned(files) {
+        return await this._post(`/api/train/${this.klassId}/challenges/review/${this.klassResultId}/presigned`, FormType.JSON, {
+            files: files,
+        });
+    }
+    async orcaHost() {
+        const asText = true;
+        const editorHtml = await this._get("/editor/1.0/coding", asText);
+        return (/data-orca-host="([^"]+)"/.exec(editorHtml) ||
+            ["", "track-prod-frontend.orca.run"])[1];
+    }
+    async orcaToken(context) {
+        return await this._get(context.urlForOrcaToken);
+    }
+    async saveFiles(files) {
+        return await this._put(`/api/train/${this.klassId}/challenges/results/${this.klassResultId}/save`, FormType.JSON, files);
+    }
+    async updateEditorScore(score) {
+        // TODO: implement the API side
+        await Promise.resolve();
+        console.log(score);
+        // return await this._put(
+        //   `/api/train/${this.klassId}/challenges/results/${this.klassResultId}/editorScore`,
+        //   FormType.JSON,
+        //   {
+        //     editorScore: score,
+        //   },
+        // );
+    }
+    async reset() {
+        return await this._put(`/api/train/${this.klassId}/challenges/results/${this.klassResultId}/reset`, FormType.JSON, {});
+    }
+}
+function toChallengeSession(tcs) {
+    return {
+        challengeId: tcs.challenge.id,
+        challengeVersionId: tcs.challenge.challengeVersionId,
+        style: tcs.challenge.style,
+        title: tcs.challenge.title,
+        description: tcs.challenge.description,
+        timeLimitMinutes: tcs.challenge.timeLimitMinutes,
+        displayOrder: tcs.challenge.displayOrder,
+        openTestcases: tcs.challenge.openTestcases,
+        programmingLanguages: tcs.challenge.programmingLanguages,
+        localCodingAllowed: tcs.challenge.localCodingEnabled,
+        result: tcs.result,
+    };
+}
+function toProgrammingLanguageInfo(pl) {
+    return {
+        value: pl.id,
+        name: pl.name,
+    };
+}

package/package.json

@@ -3,7 +3,7 @@
     "track": "./esm/src/main.js"
   },
   "name": "track-cli",
-  "version": "3.1.0",
+  "version": "4.0.0-rc0",
   "description": "A CLI for interacting with tracks.run and running code tests on track's servers",
   "license": "MIT",
   "repository": {