@juki-team/commons 0.1.11

package/dist/types/types/judge.d.ts

@@ -0,0 +1,75 @@
+import { CodeLanguage } from './commons';
+import { DataLog } from './submission';
+export type JudgeLanguage = {
+    value: string;
+    label: string;
+    enabled: boolean;
+    associatedLanguage: CodeLanguage;
+};
+export interface JudgeBaseDocument {
+    key: string | Judge;
+    name: string;
+    languages: JudgeLanguage[];
+    problemTags: string[];
+    keyPrefix: string;
+    isExternal: boolean;
+    isSubmitSupported: boolean;
+    logo: string;
+    logoSize: [number, number];
+    url: string;
+    getLoginUrl: string;
+    getProfileUrl: string;
+    getSubmitUrl: string;
+    getSubmissionUrl: string;
+    getProblemUrl: string;
+    getUserSubmissionsUrl: string;
+    submissionsWithHighPriority: boolean;
+}
+export declare enum Judge {
+    JUKI_JUDGE = "JUKI_JUDGE",
+    CODEFORCES = "CODEFORCES",
+    CODEFORCES_GYM = "CODEFORCES_GYM",
+    JV_UMSA = "JV_UMSA",
+    UVA_ONLINE_JUDGE = "UVA_ONLINE_JUDGE",
+    AT_CODER = "AT_CODER",
+    CODECHEF = "CODECHEF",
+    TOPCODER = "TOPCODER",
+    LEETCODE = "LEETCODE"
+}
+export declare enum ProblemVerdict {
+    NONE = "NONE",// No judge
+    PENDING = "PENDING",// Pending
+    HIDDEN = "HIDDEN",// Hidden
+    CE = "CE",// Compilation Error
+    RE = "RE",// Runtime Error
+    TLE = "TLE",// Time Limit Exceded
+    MLE = "MLE",// Memory Limit Exceded
+    WA = "WA",// Wrong Answer
+    PE = "PE",// Presentation Error
+    PA = "PA",// Partial Accepted
+    AC = "AC"
+}
+export declare enum SubmissionRunStatus {
+    NONE = "NONE",
+    RECEIVED = "RECEIVED",
+    COMPILING = "COMPILING",
+    COMPILED = "COMPILED",
+    COMPILATION_ERROR = "COMPILATION_ERROR",
+    FETCHING_TEST_CASES = "FETCHING_TEST_CASES",
+    RUNNING_TEST_CASE = "RUNNING_TEST_CASE",
+    RUNNING_TEST_CASES = "RUNNING_TEST_CASES",
+    RUNNING_SAMPLE_TEST_CASES = "RUNNING_SAMPLE_TEST_CASES",
+    EXECUTED_TEST_CASE = "EXECUTED_TEST_CASE",
+    FAILED_TEST_CASE = "FAILED_TEST_CASE",
+    JUDGING_TEST_CASE = "JUDGING_TEST_CASE",
+    GRADING = "GRADING",
+    FAILED = "FAILED",
+    COMPLETED = "COMPLETED"
+}
+export declare enum RunnerType {
+    HIGH_PERFORMANCE = "HIGH_PERFORMANCE",
+    LOW_PERFORMANCE = "LOW_PERFORMANCE"
+}
+export type TestCaseVerdict = DataLog & {
+    verdict: ProblemVerdict;
+};

package/dist/types/types/markdown.d.ts

@@ -0,0 +1,8 @@
+import { CodeEditorFiles, CodeLanguage, EntityMembers } from '../types';
+export interface MarkdownBaseDocument {
+    key: string;
+    name: string;
+    tags: string[];
+    members: EntityMembers;
+    files: CodeEditorFiles<CodeLanguage.MARKDOWN>;
+}

package/dist/types/types/mermaid.d.ts

@@ -0,0 +1,8 @@
+import { CodeEditorFiles, CodeLanguage, EntityMembers } from '../types';
+export interface MermaidBaseDocument {
+    key: string;
+    name: string;
+    tags: string[];
+    members: EntityMembers;
+    files: CodeEditorFiles<CodeLanguage.MERMAID>;
+}

package/dist/types/types/notification.d.ts

@@ -0,0 +1,7 @@
+export declare enum NotificationType {
+    SUCCESS = "success",
+    INFO = "info",
+    WARNING = "warning",
+    ERROR = "error",
+    QUIET = "quiet"
+}

package/dist/types/types/prisma.d.ts

@@ -0,0 +1,284 @@
+import { ProfileSetting } from './account';
+/**
+ * Model Course
+ *
+ */
+export type Course = {
+    id: number;
+    createdAt: Date;
+    updatedAt: Date;
+    key: string;
+    title: string;
+    abstract: string;
+    description: string;
+    goals: string;
+    coverImageUrl: string;
+    status: CourseStatus;
+    type: CourseType;
+};
+/**
+ * Model UsersCourses
+ *
+ */
+export type UsersCourses = {
+    createdAt: Date;
+    updatedAt: Date;
+    userId: number;
+    courseId: number;
+    invited: boolean;
+    editor: boolean;
+    owner: boolean;
+    reviewer: boolean;
+    admin: boolean;
+    enrolled: boolean;
+    unlocked: boolean;
+};
+/**
+ * Model Task
+ *
+ */
+export type TaskPrisma = {
+    id: number;
+    createdAt: Date;
+    updatedAt: Date;
+    trainingId: number;
+    name: string;
+    description: string;
+    dueDate: Date;
+};
+/**
+ * Model TaskComment
+ *
+ */
+export type TaskComment = {
+    id: number;
+    createdAt: Date;
+    updatedAt: Date;
+    taskId: number;
+    userId: number;
+    content: string;
+};
+/**
+ * Model Assignment
+ *
+ */
+export type AssignmentPrisma = {
+    id: number;
+    createdAt: Date;
+    updatedAt: Date;
+    taskId: number;
+    description: string;
+    type: AssignmentType;
+    content: string;
+};
+/**
+ * Model UsersAssignment
+ *
+ */
+export type UsersAssignment = {
+    createdAt: Date;
+    updatedAt: Date;
+    userId: number;
+    subtaskId: number;
+    status: AssignmentState;
+};
+/**
+ * Model Team
+ *
+ */
+export type TeamPrisma = {
+    id: number;
+    createdAt: Date;
+    updatedAt: Date;
+    createdByUserId: number;
+    code: string;
+    codeEnabled: boolean;
+    name: string;
+    aboutTeam: string;
+    country: string;
+    city: string;
+    institution: string;
+    imageUrl: string;
+    status: TeamStatus;
+};
+/**
+ * Model UsersTeams
+ *
+ */
+export type UsersTeams = {
+    createdAt: Date;
+    updatedAt: Date;
+    userId: number;
+    teamId: number;
+    role: MemberRole;
+    status: UserTeamStatus;
+};
+/**
+ * Model Training
+ *
+ */
+export type TrainingPrisma = {
+    id: number;
+    createdAt: Date;
+    updatedAt: Date;
+    teamId: number;
+    name: string;
+    startDate: Date;
+    endDate: Date;
+};
+/**
+ * Model User
+ *
+ */
+export type User = {
+    id: number;
+    createdAt: Date;
+    updatedAt: Date;
+    givenName: string;
+    familyName: string;
+    nickname: string;
+    imageUrl: string;
+    aboutMe: string;
+    country: string;
+    city: string;
+    institution: string;
+    email: string;
+    telegramUsername: string;
+    codeforcesHandle: string;
+    topcoderHandle: string;
+    atCoderHandle: string;
+    codeChefHandle: string;
+    [ProfileSetting.LANGUAGE]: Language;
+    [ProfileSetting.THEME]: Theme;
+    emailSubscription: EmailSubscription;
+    emailValidationState: EmailValidationState;
+    emailValidationToken: string;
+    emailValidationTimestamp: Date;
+    passwordResetToken: string | null;
+    passwordResetTimestamp: Date | null;
+    status: UserStatus;
+    userRole: UserRole;
+    teamRole: TeamRole;
+    courseRole: CourseRole;
+    password: string;
+    salt: string;
+};
+/**
+ * Enums
+ */
+export declare const CourseStatus: {
+    RELEASED: 'RELEASED';
+    IN_DRAFT: 'IN_DRAFT';
+    IN_REVIEW: 'IN_REVIEW';
+    ARCHIVED: 'ARCHIVED';
+};
+export type CourseStatus = (typeof CourseStatus)[keyof typeof CourseStatus];
+export declare const CourseType: {
+    PUBLIC: 'PUBLIC';
+    PRIVATE: 'PRIVATE';
+    CLOSED: 'CLOSED';
+};
+export type CourseType = (typeof CourseType)[keyof typeof CourseType];
+export declare const AssignmentType: {
+    READING_PDF: 'READING_PDF';
+    READING_WEB: 'READING_WEB';
+    SOLVE_JUKI_JUDGE_PROBLEM: 'SOLVE_JUKI_JUDGE_PROBLEM';
+    SOLVE_CODEFORCES_JUDGE_PROBLEM: 'SOLVE_CODEFORCES_JUDGE_PROBLEM';
+};
+export type AssignmentType = (typeof AssignmentType)[keyof typeof AssignmentType];
+export declare const AssignmentState: {
+    ASSIGNED: 'ASSIGNED';
+    IN_PROGRESS: 'IN_PROGRESS';
+    TO_REVIEW: 'TO_REVIEW';
+    RESOLVED: 'RESOLVED';
+};
+export type AssignmentState = (typeof AssignmentState)[keyof typeof AssignmentState];
+export declare const TeamStatus: {
+    ACTIVE: 'ACTIVE';
+    REPORTED: 'REPORTED';
+    ARCHIVED: 'ARCHIVED';
+};
+export type TeamStatus = (typeof TeamStatus)[keyof typeof TeamStatus];
+export declare const MemberRole: {
+    COACH: 'COACH';
+    CO_COACH: 'CO_COACH';
+    CONTESTANT: 'CONTESTANT';
+    ATTENDEE: 'ATTENDEE';
+    RESERVE: 'RESERVE';
+    STAFF: 'STAFF';
+};
+export type MemberRole = (typeof MemberRole)[keyof typeof MemberRole];
+export declare const UserTeamStatus: {
+    PENDING: 'PENDING';
+    ACCEPTED: 'ACCEPTED';
+    REJECTED: 'REJECTED';
+};
+export type UserTeamStatus = (typeof UserTeamStatus)[keyof typeof UserTeamStatus];
+export declare const Language: {
+    ES: 'ES';
+    EN: 'EN';
+};
+export type Language = (typeof Language)[keyof typeof Language];
+export declare const Theme: {
+    LIGHT: 'LIGHT';
+    DARK: 'DARK';
+};
+export type Theme = (typeof Theme)[keyof typeof Theme];
+export declare const EmailSubscription: {
+    NONE: 'NONE';
+    RANKED_CONTESTS: 'RANKED_CONTESTS';
+    WEEKLY_NEWS_SUBSCRIPTION: 'WEEKLY_NEWS_SUBSCRIPTION';
+    MONTHLY_NEWS_SUBSCRIPTION: 'MONTHLY_NEWS_SUBSCRIPTION';
+};
+export type EmailSubscription = (typeof EmailSubscription)[keyof typeof EmailSubscription];
+export declare const EmailValidationState: {
+    PENDING: 'PENDING';
+    VALIDATED: 'VALIDATED';
+};
+export type EmailValidationState = (typeof EmailValidationState)[keyof typeof EmailValidationState];
+export declare const UserStatus: {
+    ACTIVE: 'ACTIVE';
+    REPORTED: 'REPORTED';
+    ARCHIVED: 'ARCHIVED';
+};
+export type UserStatus = (typeof UserStatus)[keyof typeof UserStatus];
+export declare const UserRole: {
+    RESTRICTED: 'RESTRICTED';
+    GUEST: 'GUEST';
+    LIMITED: 'LIMITED';
+    REGULAR: 'REGULAR';
+    MANAGER: 'MANAGER';
+    ADMIN: 'ADMIN';
+    SUPER_ADMIN: 'SUPER_ADMIN';
+};
+export type UserRole = (typeof UserRole)[keyof typeof UserRole];
+export declare const SystemRole: {
+    GUEST: 'GUEST';
+    REGULAR: 'REGULAR';
+    MANAGER: 'MANAGER';
+    MASTER: 'MASTER';
+    ADMIN: 'ADMIN';
+    SUPER_ADMIN: 'SUPER_ADMIN';
+};
+export type SystemRole = (typeof SystemRole)[keyof typeof SystemRole];
+export declare const TeamRole: {
+    RESTRICTED: 'RESTRICTED';
+    GUEST: 'GUEST';
+    REGULAR: 'REGULAR';
+    MANAGER: 'MANAGER';
+    ADMIN: 'ADMIN';
+    SUPER_ADMIN: 'SUPER_ADMIN';
+};
+export type TeamRole = (typeof TeamRole)[keyof typeof TeamRole];
+export declare const CourseRole: {
+    RESTRICTED: 'RESTRICTED';
+    GUEST: 'GUEST';
+    REGULAR: 'REGULAR';
+    CREATOR: 'CREATOR';
+    SUPER_CREATOR: 'SUPER_CREATOR';
+    MANAGER: 'MANAGER';
+    MASTER: 'MASTER';
+    ADMIN: 'ADMIN';
+    SUPER_ADMIN: 'SUPER_ADMIN';
+};
+export type CourseRole = (typeof CourseRole)[keyof typeof CourseRole];

package/dist/types/types/problems.d.ts

@@ -0,0 +1,102 @@
+import { CodeLanguage, TextLanguage } from './commons';
+import { EntityMembers } from './entity';
+import { ProblemTestCase } from './services';
+export interface TestCase {
+    id: string;
+    group: number;
+    input: boolean;
+    output: boolean;
+}
+export declare enum TypeTestCase {
+    INPUT = "INPUT",
+    OUTPUT = "OUTPUT"
+}
+export declare enum ProblemInput {
+    STANDARD = "STANDARD",
+    INTERACTIVE = "INTERACTIVE"
+}
+export declare enum ProblemOutput {
+    STANDARD = "STANDARD",
+    DYNAMIC = "DYNAMIC",
+    INTERACTIVE = "INTERACTIVE"
+}
+export declare enum ProblemType {
+    STANDARD = "STANDARD",// The output is evaluated by the judge // Supported
+    DYNAMIC = "DYNAMIC",// The output is evaluated other file // Supported
+    INTERACTIVE = "INTERACTIVE"
+}
+export declare enum ProblemScoringMode {
+    SUBTASK = "SUBTASK",// by groups // Supported
+    TOTAL = "TOTAL",// one group // Supported
+    PARTIAL = "PARTIAL"
+}
+export type ProblemSettingsPointsByGroups = {
+    [key: number]: {
+        points: number;
+        partial: number;
+        group: number;
+        description: TextLanguage;
+    };
+};
+export type ProblemSettingsByProgrammingLanguage = {
+    [key: string]: {
+        language: CodeLanguage;
+        timeLimit: number;
+        memoryLimit: number;
+    };
+};
+export type ProblemSampleCases = {
+    input: string;
+    output: string;
+}[];
+export type ProblemStatement = {
+    description: TextLanguage;
+    input: TextLanguage;
+    output: TextLanguage;
+    sampleCases: ProblemSampleCases;
+    note: TextLanguage;
+    html: TextLanguage;
+    pdfUrl: TextLanguage;
+};
+export type ProblemSettings = {
+    timeLimit: number;
+    memoryLimit: number;
+    withPE: boolean;
+    type: ProblemType;
+    scoringMode: ProblemScoringMode;
+    byProgrammingLanguage: ProblemSettingsByProgrammingLanguage;
+    evaluatorSource: string;
+    pointsByGroups: ProblemSettingsPointsByGroups;
+};
+export type ProblemUser = {
+    isOwner: boolean;
+    isAdministrator: boolean;
+    isManager: boolean;
+    isSpectator: boolean;
+    solved: boolean;
+    tried: boolean;
+};
+export interface ProblemBaseDocument {
+    name: string;
+    shortname: string;
+    author: string;
+    settings: ProblemSettings;
+    tags: string[];
+    statement: ProblemStatement;
+    editorial: TextLanguage;
+    judgeId: string;
+    key: string;
+    testCases: ProblemTestCase[];
+    testCasesUpdatedAtTimestamp: number;
+    members: EntityMembers;
+    costs: {
+        unlockEditorial: number;
+        unlockHint: number;
+        viewTestCases: number;
+    };
+    rewardJukiCoins: {
+        forSolving: number;
+        forSolvingFirstTry: number;
+        forSolvingInAnExtraLanguage: number;
+    };
+}

package/dist/types/types/services.d.ts

@@ -0,0 +1,213 @@
+import { CodeLanguage } from './commons';
+export declare enum ErrorCode {
+    ERR400 = "ERR400",
+    ERR401 = "ERR401",
+    ERR403 = "ERR403",
+    ERR404 = "ERR404",
+    ERR405 = "ERR405",
+    ERR500 = "ERR500",
+    ERR9997 = "ERR9997",// 'aborted request'
+    ERR9998 = "ERR9998",// 'error on response'
+    ERR9999 = "ERR9999",// 'service no found'
+    ERR0000 = "ERR0000",
+    ERR0010 = "ERR0010",
+    ERR0011 = "ERR0011",
+    ERR0012 = "ERR0012",
+    ERR0013 = "ERR0013",
+    ERR0014 = "ERR0014",
+    ERR0015 = "ERR0015",
+    ERR0016 = "ERR0016",
+    ERR0017 = "ERR0017",
+    ERR0018 = "ERR0018",
+    ERR0019 = "ERR0019",
+    ERR0020 = "ERR0020",
+    ERR0021 = "ERR0021",
+    ERR0022 = "ERR0022",
+    ERR0023 = "ERR0023",
+    ERR0024 = "ERR0024",
+    ERR0050 = "ERR0050",
+    ERR0051 = "ERR0051",
+    ERR0052 = "ERR0052",
+    ERR0053 = "ERR0053",
+    ERR0100 = "ERR0100",
+    ERR0110 = "ERR0110",
+    ERR0111 = "ERR0111",
+    ERR0112 = " ERR0112",
+    ERR0113 = "ERR0113",
+    ERR0114 = "ERR0114",
+    ERR0115 = "ERR0115",
+    ERR0116 = "ERR0116",
+    ERR0117 = "ERR0117",
+    ERR0118 = "ERR0118",
+    ERR0119 = "ERR0119",
+    ERR0120 = "ERR0120",
+    ERR0121 = "ERR0121",
+    ERR0122 = "ERR0122",
+    ERR0200 = "ERR0200",
+    ERR0210 = "ERR0210",
+    ERR0211 = "ERR0211",
+    ERR0212 = "ERR0212",
+    ERR0213 = "ERR0213",
+    ERR0214 = "ERR0214",
+    ERR0215 = "ERR0215",
+    ERR0216 = "ERR0216",
+    ERR0217 = "ERR0217",
+    ERR0218 = "ERR0218",
+    ERR0219 = "ERR0219",
+    ERR0220 = "ERR0220",
+    ERR0230 = "ERR0230",
+    ERR0231 = "ERR0231",
+    ERR0232 = "ERR0232",
+    ERR0233 = "ERR0233",
+    ERR0234 = "ERR0234",
+    ERR0235 = "ERR0235",
+    ERR0236 = "ERR0236",
+    ERR0237 = "ERR0237",
+    ERR0240 = "ERR0240",
+    ERR0241 = "ERR0241",
+    ERR0242 = "ERR0242",
+    ERR0243 = "ERR0243",
+    ERR0244 = "ERR0244",
+    ERR0245 = "ERR0245",
+    ERR0246 = "ERR0246",
+    ERR0247 = "ERR0247",
+    ERR0300 = "ERR0300",
+    ERR0301 = "ERR0301",
+    ERR0302 = "ERR0302",
+    ERR0303 = "ERR0303",
+    ERR0310 = "ERR0310",
+    ERR0311 = "ERR0311",
+    ERR0321 = "ERR0321",
+    ERR0331 = "ERR0331",
+    ERR0400 = "ERR0400",// 'internal server error on utils services'
+    ERR0410 = "ERR0410",// 'empty image'
+    ERR0420 = "ERR0420",
+    ERR0421 = "ERR0421",
+    ERR0430 = "ERR0430",
+    ERR0440 = "ERR0440",
+    ERR0600 = "ERR0600",
+    ERR0610 = "ERR0610",
+    ERR0611 = "ERR0611",
+    ERR0612 = "ERR0612",
+    ERR0613 = "ERR0613",
+    ERR0614 = "ERR0614",
+    ERR0615 = "ERR0615",
+    ERR0616 = "ERR0665",
+    ERR0617 = "ERR0617",
+    ERR0618 = "ERR0618",
+    ERR0619 = "ERR0619",
+    ERR0800 = "ERR0800",
+    ERR0810 = "ERR0810",
+    ERR0811 = "ERR0811",
+    ERR0812 = "ERR0812",
+    ERR0813 = "ERR0813",
+    ERR0814 = "ERR0814",
+    ERR0815 = "ERR0815",
+    ERR0816 = "ERR0865",
+    ERR0817 = "ERR0817",
+    ERR0818 = "ERR0818",
+    ERR0819 = "ERR0819",
+    ERR0820 = "ERR0820",
+    ERR9900 = "ERR9900",
+    ERR9910 = "ERR9910",
+    ERR9911 = "ERR9911",
+    ERR9912 = "ERR9912",
+    ERR9913 = "ERR9913",
+    ERR9914 = "ERR9914",
+    ERR9915 = "ERR9915",
+    ERR9916 = "ERR9916",
+    ERR9917 = "ERR9917"
+}
+export type ApiError = {
+    code: ErrorCode;
+    detail: string;
+    message: string;
+};
+export type ErrorResponse = {
+    success: false;
+    message: string;
+    errors: ApiError[];
+};
+export type ContentResponse<T> = {
+    success: true;
+    message: string;
+    content: T;
+};
+export type ContentsMeta = {
+    page: number;
+    size: number;
+    totalElements: number;
+    sort: {
+        [key: string]: number;
+    }[];
+    filter: Record<any, any>;
+};
+export type ContentsResponse<T> = {
+    success: true;
+    message: string;
+    contents: T[];
+    meta: ContentsMeta;
+};
+export declare enum LogLevel {
+    FATAL = "FATAL",
+    ERROR = "ERROR",
+    WARN = "WARN",
+    INFO = "INFO",
+    DEBUG = "DEBUG",
+    TRACE = "TRACE"
+}
+export declare enum HTTPMethod {
+    POST = "POST",
+    GET = "GET",
+    PUT = "PUT",
+    PATCH = "PATCH",
+    DELETE = "DELETE"
+}
+export type RunnerNextRequest = {
+    type: 'request';
+    body: string;
+    method: HTTPMethod;
+    url: string;
+};
+export type RunnerNextQueue = {
+    type: 'queue';
+    messageBody: string;
+    messageGroupId: string;
+    messageDeduplicationId: string;
+};
+export type RunnerNext = RunnerNextRequest | RunnerNextQueue;
+export type RunCommand = {
+    commandLine: string;
+    inputFilePath: string;
+    outputFilePath: string;
+    errorFilePath: string;
+    logFilePath: string;
+    folderPath: string;
+    timeLimit: number;
+    memoryLimit: number;
+    lockFilePath?: string;
+    endFilePath?: string;
+    rawExecution: boolean;
+    isolated: boolean;
+    next?: RunnerNext;
+};
+export type RunnerSQSMessageBody = {
+    executions: RunCommand[];
+    next?: RunnerNext;
+};
+export type Case = {
+    caseKey: string;
+    groups: number[];
+};
+export type ProblemTestCase = {
+    testCaseKey: string;
+    groups: number[];
+};
+export type ProblemSampleCase = {
+    input: string;
+    output: string;
+};
+export type JudgingFile = {
+    language: CodeLanguage;
+    fullFileName: string;
+};