workspace: upgrade deps & sort imports

packages/hydrooj/src/handler/api.ts

@@ -1,7 +1,7 @@
 import graphql from 'graphql';
-import { typeDefs, resolvers } from 'graphql-scalars';
-import { Handler, Route } from '../service/server';
+import { resolvers, typeDefs } from 'graphql-scalars';
 import * as bus from '../service/bus';
+import { Handler, Route } from '../service/server';
 
 const types: Record<string, Record<string, string>> = {};
 const unions: Record<string, string> = {};

packages/hydrooj/src/handler/contest.ts

@@ -1,31 +1,31 @@
+import AdmZip from 'adm-zip';
+import { intersection } from 'lodash';
+import { lookup } from 'mime-types';
 import moment from 'moment-timezone';
 import { ObjectID } from 'mongodb';
-import AdmZip from 'adm-zip';
 import { Time } from '@hydrooj/utils/lib/utils';
-import { lookup } from 'mime-types';
-import { intersection } from 'lodash';
 import {
-    ContestNotLiveError, ValidationError, ProblemNotFoundError,
-    ContestNotAttendedError, PermissionError, BadRequestError,
-    ContestNotFoundError, InvalidTokenError, RecordNotFoundError,
-} from '../error';
+    BadRequestError,
+    ContestNotAttendedError,     ContestNotFoundError,     ContestNotLiveError, InvalidTokenError, PermissionError, ProblemNotFoundError,
+    RecordNotFoundError,
+    ValidationError } from '../error';
 import {
-    ProblemDoc, Tdoc, User, DomainDoc,
-} from '../interface';
+    DomainDoc,
+    ProblemDoc, Tdoc, User } from '../interface';
 import paginate from '../lib/paginate';
 import { PERM, PRIV } from '../model/builtin';
 import * as contest from '../model/contest';
-import * as system from '../model/system';
 import * as document from '../model/document';
-import problem from '../model/problem';
 import domain from '../model/domain';
-import record from '../model/record';
-import user from '../model/user';
 import message from '../model/message';
-import {
-    Route, Handler, Types, param,
-} from '../service/server';
+import problem from '../model/problem';
+import record from '../model/record';
+import * as system from '../model/system';
+import user from '../model/user';
 import * as bus from '../service/bus';
+import {
+    Handler, param,
+    Route, Types } from '../service/server';
 import storage from '../service/storage';
 
 export class ContestListHandler extends Handler {

packages/hydrooj/src/handler/discussion.ts

@@ -1,17 +1,17 @@
-import { ObjectID } from 'mongodb';
 import { isSafeInteger } from 'lodash';
+import { ObjectID } from 'mongodb';
 import { DiscussionNotFoundError, DocumentNotFoundError, PermissionError } from '../error';
-import { DiscussionReplyDoc, DiscussionDoc, DiscussionTailReplyDoc } from '../interface';
+import { DiscussionDoc, DiscussionReplyDoc, DiscussionTailReplyDoc } from '../interface';
 import paginate from '../lib/paginate';
-import * as system from '../model/system';
-import user from '../model/user';
-import * as oplog from '../model/oplog';
+import { PERM, PRIV } from '../model/builtin';
 import * as discussion from '../model/discussion';
 import * as document from '../model/document';
-import { PERM, PRIV } from '../model/builtin';
+import * as oplog from '../model/oplog';
+import * as system from '../model/system';
+import user from '../model/user';
 import {
-    Route, Handler, Types, param,
-} from '../service/server';
+    Handler, param,
+    Route, Types } from '../service/server';
 
 export const typeMapper = {
     problem: document.TYPE_PROBLEM,

packages/hydrooj/src/handler/domain.ts

@@ -1,24 +1,24 @@
-import moment from 'moment-timezone';
 import { Dictionary } from 'lodash';
+import moment from 'moment-timezone';
 import {
-    RoleAlreadyExistError, ValidationError, DomainJoinForbiddenError,
-    DomainJoinAlreadyMemberError, InvalidJoinInvitationCodeError,
-} from '../error';
-import { log2 } from '../utils';
+    DomainJoinAlreadyMemberError, DomainJoinForbiddenError,
+    InvalidJoinInvitationCodeError,
+    RoleAlreadyExistError, ValidationError } from '../error';
 import type { DomainDoc } from '../interface';
-import user from '../model/user';
-import domain from '../model/domain';
-import * as discussion from '../model/discussion';
-import * as system from '../model/system';
-import { DOMAIN_SETTINGS, DOMAIN_SETTINGS_BY_KEY } from '../model/setting';
-import {
-    DEFAULT_NODES, PERM, PERMS_BY_FAMILY, PRIV,
-} from '../model/builtin';
 import avatar from '../lib/avatar';
 import paginate from '../lib/paginate';
 import {
-    Route, Handler, Types, param, query, post,
-} from '../service/server';
+    DEFAULT_NODES, PERM, PERMS_BY_FAMILY, PRIV,
+} from '../model/builtin';
+import * as discussion from '../model/discussion';
+import domain from '../model/domain';
+import { DOMAIN_SETTINGS, DOMAIN_SETTINGS_BY_KEY } from '../model/setting';
+import * as system from '../model/system';
+import user from '../model/user';
+import {
+    Handler, param, post,
+    query,     Route, Types } from '../service/server';
+import { log2 } from '../utils';
 
 class DomainRankHandler extends Handler {
     @query('page', Types.PositiveInt, true)

packages/hydrooj/src/handler/home.ts

@@ -1,32 +1,32 @@
-import { ObjectID } from 'mongodb';
 import yaml from 'js-yaml';
+import { ObjectID } from 'mongodb';
 import {
-    VerifyPasswordError, UserAlreadyExistError, InvalidTokenError,
-    NotFoundError, UserNotFoundError, PermissionError,
-    DomainAlreadyExistsError, ValidationError, BlacklistedError,
-} from '../error';
-import { MessageDoc, Setting, DomainDoc } from '../interface';
-import * as bus from '../service/bus';
-import {
-    Route, Connection, Handler, ConnectionHandler, param, Types,
-} from '../service/server';
-import { md5 } from '../lib/crypto';
-import { isPassword, isEmail, isDomainId } from '../lib/validator';
+    BlacklistedError,
+    DomainAlreadyExistsError, InvalidTokenError,
+    NotFoundError, PermissionError,
+    UserAlreadyExistError, UserNotFoundError, ValidationError,     VerifyPasswordError } from '../error';
+import { DomainDoc, MessageDoc, Setting } from '../interface';
 import avatar from '../lib/avatar';
+import { md5 } from '../lib/crypto';
 import * as mail from '../lib/mail';
+import { isDomainId, isEmail, isPassword } from '../lib/validator';
+import BlackListModel from '../model/blacklist';
+import { PERM, PRIV } from '../model/builtin';
 import * as contest from '../model/contest';
-import message from '../model/message';
-import * as document from '../model/document';
-import * as system from '../model/system';
-import user from '../model/user';
-import * as setting from '../model/setting';
-import domain from '../model/domain';
 import * as discussion from '../model/discussion';
+import * as document from '../model/document';
+import domain from '../model/domain';
+import message from '../model/message';
+import ProblemModel from '../model/problem';
+import * as setting from '../model/setting';
+import * as system from '../model/system';
 import token from '../model/token';
 import * as training from '../model/training';
-import { PERM, PRIV } from '../model/builtin';
-import BlackListModel from '../model/blacklist';
-import ProblemModel from '../model/problem';
+import user from '../model/user';
+import * as bus from '../service/bus';
+import {
+    Connection, ConnectionHandler, Handler, param,     Route, Types,
+} from '../service/server';
 
 const { geoip, useragent } = global.Hydro.lib;
 

packages/hydrooj/src/handler/homework.ts

@@ -1,32 +1,32 @@
+import AdmZip from 'adm-zip';
 import yaml from 'js-yaml';
+import { intersection } from 'lodash';
+import { lookup } from 'mime-types';
 import moment from 'moment-timezone';
 import { ObjectID } from 'mongodb';
-import AdmZip from 'adm-zip';
 import { Time } from '@hydrooj/utils/lib/utils';
-import { lookup } from 'mime-types';
-import { intersection } from 'lodash';
 import {
-    ValidationError, HomeworkNotLiveError, ProblemNotFoundError,
-    HomeworkNotAttendedError, BadRequestError,
-} from '../error';
+    BadRequestError,
+    HomeworkNotAttendedError, HomeworkNotLiveError, ProblemNotFoundError,
+    ValidationError } from '../error';
 import {
-    PenaltyRules, Tdoc, ProblemDoc, User, DomainDoc,
-} from '../interface';
-import {
-    Route, Handler, Types, param,
-} from '../service/server';
-import * as bus from '../service/bus';
-import domain from '../model/domain';
+    DomainDoc,
+    PenaltyRules, ProblemDoc, Tdoc, User } from '../interface';
+import paginate from '../lib/paginate';
 import { PERM, PRIV, STATUS } from '../model/builtin';
-import user from '../model/user';
-import * as system from '../model/system';
 import * as contest from '../model/contest';
 import * as discussion from '../model/discussion';
+import * as document from '../model/document';
+import domain from '../model/domain';
 import problem from '../model/problem';
 import record from '../model/record';
 import storage from '../model/storage';
-import * as document from '../model/document';
-import paginate from '../lib/paginate';
+import * as system from '../model/system';
+import user from '../model/user';
+import * as bus from '../service/bus';
+import {
+    Handler, param,
+    Route, Types } from '../service/server';
 
 const validatePenaltyRules = (input: string) => yaml.load(input);
 const convertPenaltyRules = validatePenaltyRules;

packages/hydrooj/src/handler/import.ts

@@ -1,27 +1,27 @@
 /* eslint-disable no-await-in-loop */
-import fs from 'fs-extra';
-import path from 'path';
-import os from 'os';
 import assert from 'assert';
-import superagent from 'superagent';
-import { filter } from 'lodash';
+import os from 'os';
+import path from 'path';
 import { PassThrough } from 'stream';
 import AdmZip from 'adm-zip';
+import fs from 'fs-extra';
 import yaml from 'js-yaml';
+import { filter } from 'lodash';
+import superagent from 'superagent';
 import { noop } from '@hydrooj/utils/lib/utils';
-import { ValidationError, RemoteOnlineJudgeError } from '../error';
-import { Logger } from '../logger';
+import { RemoteOnlineJudgeError, ValidationError } from '../error';
 import type { ContentNode, ProblemConfigFile, SubtaskConfig } from '../interface';
+import { buildContent } from '../lib/content';
+import download from '../lib/download';
+import { ProblemAdd } from '../lib/ui';
+import { isPid, parsePid } from '../lib/validator';
+import { Logger } from '../logger';
+import { PERM, PRIV } from '../model/builtin';
 import problem, { ProblemDoc } from '../model/problem';
 import TaskModel from '../model/task';
-import { PERM, PRIV } from '../model/builtin';
 import {
-    Route, Handler, Types, post,
-} from '../service/server';
-import { isPid, parsePid } from '../lib/validator';
-import download from '../lib/download';
-import { buildContent } from '../lib/content';
-import { ProblemAdd } from '../lib/ui';
+    Handler, post,
+    Route, Types } from '../service/server';
 
 const RE_SYZOJ = /(https?):\/\/([^/]+)\/(problem|p)\/([0-9]+)\/?/i;
 const logger = new Logger('import.syzoj');

packages/hydrooj/src/handler/judge.ts

@@ -1,22 +1,22 @@
 import { ObjectID } from 'mongodb';
 import { JudgeResultBody, RecordDoc, TestCase } from '../interface';
-import { sleep } from '../utils';
-import { Logger } from '../logger';
 import difficultyAlgorithm from '../lib/difficulty';
-import record from '../model/record';
-import problem from '../model/problem';
-import * as setting from '../model/setting';
+import { Logger } from '../logger';
 import * as builtin from '../model/builtin';
 import * as contest from '../model/contest';
 import domain from '../model/domain';
-import task from '../model/task';
-import * as system from '../model/system';
+import problem from '../model/problem';
+import record from '../model/record';
+import * as setting from '../model/setting';
 import storage from '../model/storage';
+import * as system from '../model/system';
+import task from '../model/task';
 import * as bus from '../service/bus';
-import {
-    Route, Handler, Connection, ConnectionHandler, post, Types,
-} from '../service/server';
 import { updateJudge } from '../service/monitor';
+import {
+    Connection, ConnectionHandler, Handler, post,     Route, Types,
+} from '../service/server';
+import { sleep } from '../utils';
 
 const logger = new Logger('judge');
 

packages/hydrooj/src/handler/manage.ts

@@ -1,22 +1,22 @@
 import { inspect } from 'util';
 import * as yaml from 'js-yaml';
-import * as judge from './judge';
-import { ValidationError } from '../error';
 import * as check from '../check';
+import { ValidationError } from '../error';
+import {
+    isEmail, isPassword,
+    isUname,     validate } from '../lib/validator';
 import { Logger } from '../logger';
+import { PRIV, STATUS } from '../model/builtin';
+import domain from '../model/domain';
+import record from '../model/record';
 import * as setting from '../model/setting';
 import * as system from '../model/system';
 import user from '../model/user';
-import { STATUS, PRIV } from '../model/builtin';
-import record from '../model/record';
-import domain from '../model/domain';
-import {
-    Route, Connection, Handler, ConnectionHandler, param, Types,
-} from '../service/server';
 import * as bus from '../service/bus';
 import {
-    validate, isEmail, isUname, isPassword,
-} from '../lib/validator';
+    Connection, ConnectionHandler, Handler, param,     Route, Types,
+} from '../service/server';
+import * as judge from './judge';
 
 const logger = new Logger('manage');
 

packages/hydrooj/src/handler/misc.ts

@@ -4,14 +4,14 @@ import { lookup } from 'mime-types';
 import {
     BadRequestError, ForbiddenError, ValidationError,
 } from '../error';
-import { sortFiles } from '../utils';
 import { PRIV } from '../model/builtin';
 import storage from '../model/storage';
 import * as system from '../model/system';
 import user from '../model/user';
 import {
-    Route, Handler, Types, param, post,
-} from '../service/server';
+    Handler, param, post,
+    Route, Types } from '../service/server';
+import { sortFiles } from '../utils';
 
 class CheckInHandler extends Handler {
     async prepare() {

packages/hydrooj/src/handler/notfound.ts

@@ -2,7 +2,7 @@
 /* eslint-disable class-methods-use-this */
 import { NotFoundError } from '../error';
 import {
-    Route, Handler, param, Types,
+    Handler, param,     Route, Types,
 } from '../service/server';
 
 class NotFoundHandler extends Handler {

packages/hydrooj/src/handler/problem.ts

@@ -1,34 +1,34 @@
-import { isSafeInteger, flatten, intersection } from 'lodash';
-import { FilterQuery, ObjectID } from 'mongodb';
 import AdmZip from 'adm-zip';
-import { sortFiles } from '@hydrooj/utils/lib/utils';
+import { flatten, intersection, isSafeInteger } from 'lodash';
 import { lookup } from 'mime-types';
-import { registerResolver, registerValue } from './api';
+import { FilterQuery, ObjectID } from 'mongodb';
+import { sortFiles } from '@hydrooj/utils/lib/utils';
 import {
-    NoProblemError, PermissionError, ValidationError,
-    SolutionNotFoundError, ProblemNotFoundError, BadRequestError,
+    BadRequestError,
     ForbiddenError,
+    NoProblemError, PermissionError, ProblemNotFoundError,     SolutionNotFoundError, ValidationError,
 } from '../error';
 import {
-    ProblemDoc, User, ProblemStatusDoc,
-} from '../interface';
+    ProblemDoc, ProblemStatusDoc,
+    User } from '../interface';
+import difficultyAlgorithm from '../lib/difficulty';
 import paginate from '../lib/paginate';
 import { isPid, parsePid as convertPid } from '../lib/validator';
-import difficultyAlgorithm from '../lib/difficulty';
-import * as system from '../model/system';
+import { PERM, PRIV } from '../model/builtin';
+import * as contest from '../model/contest';
+import * as document from '../model/document';
+import domain from '../model/domain';
 import problem from '../model/problem';
 import record from '../model/record';
-import domain from '../model/domain';
-import user from '../model/user';
-import * as document from '../model/document';
-import * as contest from '../model/contest';
 import solution from '../model/solution';
-import { PERM, PRIV } from '../model/builtin';
 import storage from '../model/storage';
+import * as system from '../model/system';
+import user from '../model/user';
 import * as bus from '../service/bus';
 import {
-    Route, Handler, Types, param, post, route, query,
-} from '../service/server';
+    Handler, param, post, query,
+    Route, route, Types } from '../service/server';
+import { registerResolver, registerValue } from './api';
 
 export const parseCategory = (value: string) => flatten(value.replace(/，/g, ',').split(',')).map((e) => e.trim());
 export const parsePid = (value: string) => (isSafeInteger(value) ? +value : value);

packages/hydrooj/src/handler/record.ts

@@ -1,23 +1,23 @@
-import { FilterQuery, ObjectID } from 'mongodb';
 import { pick } from 'lodash';
-import { postJudge } from './judge';
+import { FilterQuery, ObjectID } from 'mongodb';
 import {
     ContestNotAttendedError, ContestNotFoundError, PermissionError,
     ProblemNotFoundError, RecordNotFoundError, UserNotFoundError,
 } from '../error';
-import { buildProjection } from '../utils';
 import { RecordDoc } from '../interface';
-import { PERM, STATUS, PRIV } from '../model/builtin';
-import * as system from '../model/system';
+import { PERM, PRIV, STATUS } from '../model/builtin';
+import * as contest from '../model/contest';
 import problem from '../model/problem';
 import record from '../model/record';
-import * as contest from '../model/contest';
-import user from '../model/user';
+import * as system from '../model/system';
 import TaskModel from '../model/task';
+import user from '../model/user';
 import * as bus from '../service/bus';
 import {
-    Route, Handler, Connection, ConnectionHandler, Types, param,
-} from '../service/server';
+    Connection, ConnectionHandler, Handler, param,
+    Route, Types } from '../service/server';
+import { buildProjection } from '../utils';
+import { postJudge } from './judge';
 
 class RecordListHandler extends Handler {
     @param('page', Types.PositiveInt, true)

packages/hydrooj/src/handler/status.ts

@@ -1,11 +1,11 @@
 import { PRIV } from '../model/builtin';
-import RecordModel from '../model/record';
-import DomainModel from '../model/domain';
 import * as DocumentModel from '../model/document';
-import db from '../service/db';
-import * as bus from '../service/bus';
-import { Route, Handler } from '../service/server';
+import DomainModel from '../model/domain';
+import RecordModel from '../model/record';
 import UserModel from '../model/user';
+import * as bus from '../service/bus';
+import db from '../service/db';
+import { Handler, Route } from '../service/server';
 
 const coll = db.collection('status');
 

packages/hydrooj/src/handler/training.ts

@@ -1,19 +1,19 @@
 import assert from 'assert';
 import { FilterQuery, ObjectID } from 'mongodb';
+import { ProblemNotFoundError, ValidationError } from '../error';
 import { Tdoc, TrainingDoc } from '../interface';
-import { ValidationError, ProblemNotFoundError } from '../error';
-import { isContent, isDescription } from '../lib/validator';
 import paginate from '../lib/paginate';
-import * as system from '../model/system';
+import { isContent, isDescription } from '../lib/validator';
 import { PERM, PRIV } from '../model/builtin';
-import problem from '../model/problem';
 import * as builtin from '../model/builtin';
+import problem from '../model/problem';
+import * as system from '../model/system';
 import * as training from '../model/training';
 import user from '../model/user';
 import * as bus from '../service/bus';
 import {
-    Route, Handler, Types, param,
-} from '../service/server';
+    Handler, param,
+    Route, Types } from '../service/server';
 
 async function _parseDagJson(domainId: string, _dag: string): Promise<Tdoc['dag']> {
     const parsed = [];

packages/hydrooj/src/handler/user.ts

@@ -1,27 +1,27 @@
 import moment from 'moment-timezone';
-import { registerResolver, registerValue } from './api';
 import {
-    UserAlreadyExistError, InvalidTokenError, VerifyPasswordError,
-    UserNotFoundError, SystemError, BlacklistedError,
-    UserFacingError, LoginError,
+    BlacklistedError,
+    InvalidTokenError, LoginError,
+    SystemError,     UserAlreadyExistError,     UserFacingError,     UserNotFoundError, VerifyPasswordError,
 } from '../error';
 import { User } from '../interface';
-import {
-    Route, Handler, Types, param, post,
-} from '../service/server';
-import user from '../model/user';
-import oauth from '../model/oauth';
-import token from '../model/token';
-import record from '../model/record';
-import problem, { ProblemDoc } from '../model/problem';
-import task from '../model/task';
-import * as system from '../model/system';
-import { PERM, PRIV } from '../model/builtin';
-import BlackListModel from '../model/blacklist';
-import { isEmail, isPassword, isUname } from '../lib/validator';
+import avatar from '../lib/avatar';
 import { sendMail } from '../lib/mail';
 import paginate from '../lib/paginate';
-import avatar from '../lib/avatar';
+import { isEmail, isPassword, isUname } from '../lib/validator';
+import BlackListModel from '../model/blacklist';
+import { PERM, PRIV } from '../model/builtin';
+import oauth from '../model/oauth';
+import problem, { ProblemDoc } from '../model/problem';
+import record from '../model/record';
+import * as system from '../model/system';
+import task from '../model/task';
+import token from '../model/token';
+import user from '../model/user';
+import {
+    Handler, param, post,
+    Route, Types } from '../service/server';
+import { registerResolver, registerValue } from './api';
 
 registerValue('User', [
     ['_id', 'Int!'],