@juki-team/commons 0.1.32 → 0.1.40

package/dist/types/{course.d.ts → types/course.d.ts}

@@ -1,4 +1,4 @@
-import type { EntityMembers, EntityState } from './entity.js';
+import { EntityMembers, EntityState } from './entity';
 export interface CourseBaseDocument {
     key: string;
     title: string;

package/dist/types/{entity.d.ts → types/entity.d.ts}

@@ -1,4 +1,4 @@
-import type { UserOrganizationBasicInfoResponseDTO } from '../dto/index.js';
+import { UserCompanyBasicInfoResponseDTO } from '../dto';
 export declare enum EntityMembersRank {
     NONE = "NONE",
     CLOSE = "CLOSE",
@@ -58,8 +58,8 @@ export interface EntityLogChanges {
     key: string;
     path: string;
     valueType: string | null;
-    value?: unknown;
-    oldValue?: unknown;
+    value?: any;
+    oldValue?: any;
     type: LogOperation;
 }
 export interface EntityLog {
@@ -112,5 +112,5 @@ export declare enum LogOperation {
 export interface LogDataResponseDTO {
     changes: EntityLogChanges[];
     timestamp: number;
-    customerUser: UserOrganizationBasicInfoResponseDTO;
+    customerUser: UserCompanyBasicInfoResponseDTO;
 }

package/dist/types/{excalidraw.d.ts → types/excalidraw.d.ts}

@@ -1,9 +1,9 @@
-import type { EntityMembers } from './entity.js';
+import { EntityMembers } from './entity';
 export interface ExcalidrawBaseDocument {
     key: string;
     name: string;
-    elements: unknown;
-    appState: unknown;
+    elements: any;
+    appState: any;
     members: EntityMembers;
     tags: string[];
 }

package/dist/types/{file.d.ts → types/file.d.ts}

@@ -1,13 +1,18 @@
-import type { FileType } from '../prisma/enums/index.js';
+import { Role } from './users';
+export type FileRole = Role.RESTRICTED | Role.GUEST | Role.REGULAR | Role.MASTER | Role.ADMIN | Role.SUPER_ADMIN;
 export declare enum FileMemberRole {
     VIEWER = "VIEWER",
     EDITOR = "EDITOR"
 }
+export declare enum FileType {
+    FOLDER = "FOLDER",
+    FILE = "FILE"
+}
 export type FolderFileContent = {
-    type: typeof FileType.FOLDER;
+    type: FileType.FOLDER;
 };
 export type FileFileContent = {
-    type: typeof FileType.FILE;
+    type: FileType.FILE;
     mime: string;
     key: string;
 };
@@ -15,7 +20,7 @@ export type FileContent = FolderFileContent | FileFileContent;
 export type SummaryFileContent = FolderFileContent | Omit<FileFileContent, 'key'>;
 export declare enum FilesJukiPub {
     SHARED = "shared",// files to share
-    SHARED_EXCALIDRAW = "shared/E",// `shared/${CollectionKey.EXCALIDRAW}`,
+    SHARED_EXCALIDRAW = "shared/E",
     TEMP = "temp",// temporal files
     PROBLEMS = "problems",
     CONTESTS = "contests"

package/dist/types/{group.d.ts → types/group.d.ts}

@@ -1,5 +1,8 @@
-import type { GroupType } from '../prisma/enums/index.js';
-import type { EntityMembers, EntityState } from './entity.js';
+import { EntityMembers, EntityState } from './entity';
+export declare enum GroupType {
+    CLASS = "CLASS",
+    TEAM = "TEAM"
+}
 export interface GroupBaseDocument {
     name: string;
     description: string;

package/dist/types/types/index.d.ts

@@ -0,0 +1,25 @@
+export * from './account';
+export * from './class';
+export * from './comments';
+export * from './commons';
+export * from './company';
+export * from './contest';
+export * from './course';
+export * from './entity';
+export * from './excalidraw';
+export * from './file';
+export * from './group';
+export * from './judge';
+export * from './markdown';
+export * from './mermaid';
+export * from './notification';
+export * from './prisma';
+export * from './problems';
+export * from './services';
+export * from './sheet';
+export * from './socket';
+export * from './submission';
+export * from './teams';
+export * from './users';
+export * from './virtual-user';
+export * from './worksheet';

package/dist/types/{judge.d.ts → types/judge.d.ts}

@@ -1,6 +1,5 @@
-import type { ProblemVerdict } from '../prisma/enums/index.js';
-import type { CodeLanguage } from './commons.js';
-import type { DataLog } from './submission.js';
+import { CodeLanguage } from './commons';
+import { DataLog } from './submission';
 export type JudgeLanguage = {
     value: string;
     label: string;
@@ -37,6 +36,36 @@ export declare enum Judge {
     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"

package/dist/types/{markdown.d.ts → types/markdown.d.ts}

@@ -1,4 +1,4 @@
-import type { CodeEditorFiles, CodeLanguage, EntityMembers } from '../types/index.js';
+import { CodeEditorFiles, CodeLanguage, EntityMembers } from '../types';
 export interface MarkdownBaseDocument {
     key: string;
     name: string;

package/dist/types/{mermaid.d.ts → types/mermaid.d.ts}

@@ -1,4 +1,4 @@
-import type { CodeEditorFiles, CodeLanguage, EntityMembers } from '../types/index.js';
+import { CodeEditorFiles, CodeLanguage, EntityMembers } from '../types';
 export interface MermaidBaseDocument {
     key: string;
     name: string;

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/{problems.d.ts → types/problems.d.ts}

@@ -1,7 +1,6 @@
-import type { ProblemScoringMode, ProblemType } from '../prisma/enums/index.js';
-import type { CodeLanguage, TextLanguage } from './commons.js';
-import type { EntityMembers } from './entity.js';
-import type { ProblemTestCase } from './services.js';
+import { CodeLanguage, TextLanguage } from './commons';
+import { EntityMembers } from './entity';
+import { ProblemTestCase } from './services';
 export interface TestCase {
     id: string;
     group: number;
@@ -21,6 +20,16 @@ export declare enum ProblemOutput {
     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;

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;
+};