workspace: upgrade deps & sort imports

packages/center/handler.ts

@@ -1,9 +1,9 @@
+import crypto from 'crypto';
+import yaml from 'js-yaml';
 import db from 'hydrooj/src/service/db';
 import {
     Handler, post, Route, Types,
 } from 'hydrooj/src/service/server';
-import crypto from 'crypto';
-import yaml from 'js-yaml';
 
 function decrypt(encrypted: string) {
     if (!encrypted) throw new Error();

packages/easy-locale/model.ts

@@ -1,7 +1,7 @@
 import yaml from 'js-yaml';
-import * as bus from 'hydrooj/src/service/bus';
-import * as system from 'hydrooj/src/model/system';
 import i18n from 'hydrooj/src/lib/i18n';
+import * as system from 'hydrooj/src/model/system';
+import * as bus from 'hydrooj/src/service/bus';
 
 bus.once('app/started', () => {
     const langs = system.get('easy-locale.langs');

packages/fps-importer/handler.ts

@@ -1,17 +1,17 @@
 /* eslint-disable no-await-in-loop */
 import AdmZip from 'adm-zip';
-import xml2js from 'xml2js';
+import decodeHTML from 'decode-html';
 import fs from 'fs-extra';
 import { filter } from 'lodash';
-import decodeHTML from 'decode-html';
-import { Route, Handler } from 'hydrooj/src/service/server';
+import xml2js from 'xml2js';
+import type { ContentNode, ProblemConfigFile } from 'hydrooj';
+import { FileTooLargeError, ValidationError } from 'hydrooj/src/error';
 import { buildContent } from 'hydrooj/src/lib/content';
 import { ProblemAdd } from 'hydrooj/src/lib/ui';
-import solution from 'hydrooj/src/model/solution';
-import problem from 'hydrooj/src/model/problem';
 import { PERM } from 'hydrooj/src/model/builtin';
-import { FileTooLargeError, ValidationError } from 'hydrooj/src/error';
-import type { ContentNode, ProblemConfigFile } from 'hydrooj';
+import problem from 'hydrooj/src/model/problem';
+import solution from 'hydrooj/src/model/solution';
+import { Handler, Route } from 'hydrooj/src/service/server';
 
 class FpsProblemImportHandler extends Handler {
     async get() {

packages/fps-importer/package.json

@@ -11,7 +11,7 @@
         "adm-zip": "^0.5.5",
         "decode-html": "^2.0.0",
         "fs-extra": "^10.0.0",
-        "mongodb": "^3.6.12",
+        "mongodb": "^3.7.0",
         "xml2js": "^0.4.23"
     },
     "devDependencies": {

packages/geoip/lib.ts

@@ -1,4 +1,5 @@
 import 'hydrooj';
+
 import fs from 'fs';
 import { Reader } from 'maxmind';
 import { findFileSync } from '@hydrooj/utils/lib/utils';

packages/hydrojudge/package.json

@@ -7,16 +7,16 @@
     "repository": "https://github.com/hydro-dev/Hydro.git",
     "dependencies": {
         "@hydrooj/utils": "workspace:*",
-        "axios": "^0.21.1",
+        "axios": "^0.21.4",
         "cac": "^6.7.3",
-        "esbuild": "^0.12.24",
+        "esbuild": "^0.12.26",
         "fs-extra": "^10.0.0",
         "js-yaml": "^4.1.0",
         "lodash": "^4.17.21",
-        "mongodb": "^3.6.12",
+        "mongodb": "^3.7.0",
         "p-queue": "^7.1.0",
         "shell-quote": "^1.7.2",
-        "ws": "^8.2.1"
+        "ws": "^8.2.2"
     },
     "preferUnplugged": true,
     "license": "AGPL-3.0-or-later",

packages/hydrojudge/src/cache.ts

@@ -1,8 +1,8 @@
 import path from 'path';
-import fs from 'fs-extra';
 import cac from 'cac';
-import { Logger } from './log';
+import fs from 'fs-extra';
 import { getConfig } from './config';
+import { Logger } from './log';
 
 const argv = cac().parse();
 

packages/hydrojudge/src/cases.ts

@@ -1,12 +1,12 @@
-import fs from 'fs-extra';
 import path from 'path';
+import fs from 'fs-extra';
 import yaml from 'js-yaml';
 import { max, sum } from 'lodash';
 import readYamlCases, { convertIniConfig } from '@hydrooj/utils/lib/cases';
 import { changeErrorType } from '@hydrooj/utils/lib/utils';
-import { FormatError, SystemError } from './error';
-import { parseTimeMS, parseMemoryMB, ensureFile } from './utils';
 import { getConfig } from './config';
+import { FormatError, SystemError } from './error';
+import { ensureFile, parseMemoryMB, parseTimeMS } from './utils';
 
 interface Re0 {
     reg: RegExp,

packages/hydrojudge/src/checkers.ts

@@ -1,8 +1,8 @@
 /* eslint-disable no-template-curly-in-string */
+import { SystemError } from './error';
+import { run } from './sandbox';
 import * as STATUS from './status';
 import { parse } from './testlib';
-import { run } from './sandbox';
-import { SystemError } from './error';
 
 interface CheckResult {
     status: number,

packages/hydrojudge/src/compile.ts

@@ -1,9 +1,9 @@
 import { LangConfig } from '@hydrooj/utils/lib/lang';
-import * as STATUS from './status';
-import { run, del } from './sandbox';
 import { CompileError } from './error';
-import { compilerText } from './utils';
 import { Execute } from './interface';
+import { del, run } from './sandbox';
+import * as STATUS from './status';
+import { compilerText } from './utils';
 
 export = async function compile(
     lang: LangConfig, code: string, target: string, copyIn: any = {}, next?: Function,

packages/hydrojudge/src/config.ts

@@ -1,7 +1,7 @@
 /* eslint-disable prefer-const */
-import cac from 'cac';
 import os from 'os';
 import path from 'path';
+import cac from 'cac';
 import fs from 'fs-extra';
 import yaml from 'js-yaml';
 

packages/hydrojudge/src/daemon.ts

@@ -12,10 +12,10 @@
      `-.__          听取人生经验。  __.-'
           ````- - -.......- - -'''    ~
        ~                   */
-import * as Session from './hosts/index';
-import { sleep, Queue } from './utils';
 import { getConfig } from './config';
+import * as Session from './hosts/index';
 import log from './log';
+import { Queue, sleep } from './utils';
 
 declare global {
     namespace NodeJS {

packages/hydrojudge/src/hosts/hydro.ts

@@ -1,24 +1,24 @@
 /* eslint-disable no-await-in-loop */
 import path from 'path';
 import axios from 'axios';
-import fs from 'fs-extra';
-import WebSocket from 'ws';
-import PQueue from 'p-queue';
 import cac from 'cac';
+import fs from 'fs-extra';
 import { noop } from 'lodash';
 import { ObjectID } from 'mongodb';
+import PQueue from 'p-queue';
+import WebSocket from 'ws';
 import { LangConfig } from '@hydrooj/utils/lib/lang';
-import * as tmpfs from '../tmpfs';
+import readCases from '../cases';
+import { getConfig } from '../config';
+import { CompileError, FormatError, SystemError } from '../error';
+import judge from '../judge';
 import log from '../log';
+import { STATUS_COMPILE_ERROR, STATUS_SYSTEM_ERROR } from '../status';
+import * as sysinfo from '../sysinfo';
+import * as tmpfs from '../tmpfs';
 import {
     compilerText, Lock, md5, Queue,
 } from '../utils';
-import { getConfig } from '../config';
-import { FormatError, CompileError, SystemError } from '../error';
-import { STATUS_COMPILE_ERROR, STATUS_SYSTEM_ERROR } from '../status';
-import readCases from '../cases';
-import judge from '../judge';
-import * as sysinfo from '../sysinfo';
 
 const argv = cac().parse();
 

packages/hydrojudge/src/judge/default.ts

@@ -1,14 +1,14 @@
-import Queue from 'p-queue';
 import path from 'path';
 import fs from 'fs-extra';
-import * as STATUS from '../status';
-import { CompileError, SystemError } from '../error';
-import { parseFilename } from '../utils';
-import { run } from '../sandbox';
-import compile from '../compile';
-import signals from '../signals';
+import Queue from 'p-queue';
 import { check, compileChecker } from '../check';
+import compile from '../compile';
 import { getConfig } from '../config';
+import { CompileError, SystemError } from '../error';
+import { run } from '../sandbox';
+import signals from '../signals';
+import * as STATUS from '../status';
+import { parseFilename } from '../utils';
 
 const Score = {
     sum: (a: number, b: number) => (a + b),

packages/hydrojudge/src/judge/hack.ts

@@ -1,13 +1,13 @@
 // Not implemented
 import path from 'path';
 import fs from 'fs-extra';
-import * as STATUS from '../status';
-import { CompileError } from '../error';
-import { copyInDir, parseFilename } from '../utils';
-import { run } from '../sandbox';
-import compile from '../compile';
-import signals from '../signals';
 import { check, compileChecker } from '../check';
+import compile from '../compile';
+import { CompileError } from '../error';
+import { run } from '../sandbox';
+import signals from '../signals';
+import * as STATUS from '../status';
+import { copyInDir, parseFilename } from '../utils';
 
 export const judge = async (ctx) => {
     if (ctx.config.template) {

packages/hydrojudge/src/judge/index.ts

@@ -1,8 +1,8 @@
 import * as def from './default';
+import * as hack from './hack';
 import * as interactive from './interactive';
 import * as run from './run';
 import * as submit_answer from './submit_answer';
-import * as hack from './hack';
 
 export = {
     default: def, interactive, run, submit_answer, hack, objective: submit_answer,

packages/hydrojudge/src/judge/interactive.ts

@@ -1,12 +1,12 @@
-import Queue from 'p-queue';
 import fs from 'fs-extra';
+import Queue from 'p-queue';
+import compile from '../compile';
+import { getConfig } from '../config';
+import { run } from '../sandbox';
+import signals from '../signals';
 import * as STATUS from '../status';
 import { parse } from '../testlib';
 import { findFileSync, parseFilename } from '../utils';
-import { run } from '../sandbox';
-import compile from '../compile';
-import signals from '../signals';
-import { getConfig } from '../config';
 
 const testlibSrc = findFileSync('@hydrooj/hydrojudge/vendor/testlib/testlib.h');
 const Score = {

packages/hydrojudge/src/judge/run.ts

@@ -1,11 +1,11 @@
-import fs from 'fs-extra';
 import path from 'path';
-import * as STATUS from '../status';
-import { run } from '../sandbox';
+import fs from 'fs-extra';
 import compile from '../compile';
-import signals from '../signals';
-import { compilerText, parseMemoryMB, parseTimeMS } from '../utils';
 import { CompileError } from '../error';
+import { run } from '../sandbox';
+import signals from '../signals';
+import * as STATUS from '../status';
+import { compilerText, parseMemoryMB, parseTimeMS } from '../utils';
 
 export const judge = async (ctx) => {
     ctx.stat.judge = new Date();

packages/hydrojudge/src/log.ts

@@ -1,4 +1,4 @@
-import { inspect, InspectOptions, format } from 'util';
+import { format, inspect, InspectOptions } from 'util';
 import cac from 'cac';
 
 const argv = cac().parse();

packages/hydrojudge/src/sandbox.ts

@@ -1,11 +1,11 @@
 import Axios from 'axios';
-import fs from 'fs-extra';
 import cac from 'cac';
-import * as STATUS from './status';
-import { FormatError, SystemError } from './error';
-import { cmd, parseMemoryMB } from './utils';
+import fs from 'fs-extra';
 import { getConfig } from './config';
+import { FormatError, SystemError } from './error';
 import { Logger } from './log';
+import * as STATUS from './status';
+import { cmd, parseMemoryMB } from './utils';
 
 const argv = cac().parse();
 const logger = new Logger('sandbox');

packages/hydrojudge/src/service.ts

@@ -1,19 +1,20 @@
 // Hydro Integration
 /* eslint-disable no-await-in-loop */
 import 'hydrooj';
+
 import path from 'path';
-import { ObjectID } from 'mongodb';
 import fs from 'fs-extra';
 import { noop } from 'lodash';
+import { ObjectID } from 'mongodb';
 import { Logger } from 'hydrooj/src/logger';
 import * as monitor from 'hydrooj/src/service/monitor';
-import * as sysinfo from './sysinfo';
-import * as tmpfs from './tmpfs';
-import { FormatError, CompileError, SystemError } from './error';
-import { STATUS_COMPILE_ERROR, STATUS_SYSTEM_ERROR } from './status';
-import { compilerText, md5 } from './utils';
 import readCases from './cases';
 import { getConfig } from './config';
+import { CompileError, FormatError, SystemError } from './error';
+import { STATUS_COMPILE_ERROR, STATUS_SYSTEM_ERROR } from './status';
+import * as sysinfo from './sysinfo';
+import * as tmpfs from './tmpfs';
+import { compilerText, md5 } from './utils';
 
 declare module 'hydrooj/src/interface' {
     interface SystemKeys {

packages/hydrojudge/src/sysinfo.ts

@@ -2,9 +2,9 @@ import path from 'path';
 import fs from 'fs-extra';
 import { noop } from 'lodash';
 import { get as _get } from '@hydrooj/utils/lib/sysinfo';
+import { getConfig } from './config';
 import { judge } from './judge/run';
 import * as tmpfs from './tmpfs';
-import { getConfig } from './config';
 
 export { update } from '@hydrooj/utils/lib/sysinfo';
 

packages/hydrojudge/src/tmpfs.ts

@@ -1,6 +1,6 @@
 import child from 'child_process';
-import fs from 'fs-extra';
 import os from 'os';
+import fs from 'fs-extra';
 import log from './log';
 
 const linux = os.platform() === 'linux';

packages/hydrojudge/src/utils.ts

@@ -1,9 +1,9 @@
-import fs from 'fs-extra';
 import crypto from 'crypto';
-import path from 'path';
-import { parse } from 'shell-quote';
-import _ from 'lodash';
 import { EventEmitter } from 'events';
+import path from 'path';
+import fs from 'fs-extra';
+import _ from 'lodash';
+import { parse } from 'shell-quote';
 import { sleep } from '@hydrooj/utils/lib/utils';
 import { FormatError } from './error';
 

packages/hydrooj/package.json

@@ -19,8 +19,8 @@
         "cookies": "^0.8.0",
         "detect-browser": "^5.2.0",
         "fs-extra": "^10.0.0",
-        "graphql": "^15.5.2",
-        "graphql-scalars": "^1.10.0",
+        "graphql": "^15.5.3",
+        "graphql-scalars": "^1.10.1",
         "js-yaml": "^4.1.0",
         "koa": "^2.13.1",
         "koa-body": "^4.2.0",
@@ -33,19 +33,18 @@
         "mime-types": "^2.1.32",
         "minio": "7.0.17",
         "moment-timezone": "^0.5.33",
-        "mongodb": "^3.6.12",
+        "mongodb": "^3.7.0",
         "nanoid": "^3.1.25",
         "nodemailer": "^6.6.3",
         "p-queue": "^7.1.0",
         "reflect-metadata": "^0.1.13",
         "serialize-javascript": "^6.0.0",
         "sockjs": "^0.3.21",
-        "source-map-support": "^0.5.19",
+        "source-map-support": "^0.5.20",
         "superagent": "^6.1.0"
     },
     "devDependencies": {
         "@types/adm-zip": "^0.4.34",
-        "@types/express-serve-static-core": "^4.17.24",
         "@types/fs-extra": "^9.0.12",
         "@types/js-yaml": "^4.0.3",
         "@types/koa": "^2.13.4",

packages/hydrooj/src/entry/cli.ts

@@ -1,15 +1,15 @@
 /* eslint-disable no-await-in-loop */
-/* eslint-disable import/no-dynamic-require */
-import { ObjectID } from 'mongodb';
 import cac from 'cac';
-import {
-    lib, service, model, script,
-    builtinLib, builtinModel, builtinScript,
-} from './common';
-import options from '../options';
+import { ObjectID } from 'mongodb';
 import { validate } from '../lib/validator';
+import options from '../options';
 import * as bus from '../service/bus';
 import db from '../service/db';
+import {
+    builtinLib, builtinModel, builtinScript,
+    lib, model, script,
+    service,
+} from './common';
 
 const argv = cac().parse();
 const COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/mg;

packages/hydrooj/src/entry/common.ts

@@ -1,8 +1,8 @@
 /* eslint-disable no-await-in-loop */
 /* eslint-disable no-eval */
-import fs from 'fs-extra';
 import os from 'os';
 import path from 'path';
+import fs from 'fs-extra';
 import yaml from 'js-yaml';
 import { Logger } from '../logger';
 import * as bus from '../service/bus';

packages/hydrooj/src/entry/setup.ts

@@ -1,12 +1,12 @@
+import http from 'http';
 import os from 'os';
 import path from 'path';
-import http from 'http';
+import cac from 'cac';
 import fs from 'fs-extra';
 import Koa, { Context } from 'koa';
 import Body from 'koa-body';
 import cache from 'koa-static-cache';
 import mongodb from 'mongodb';
-import cac from 'cac';
 import { Logger } from '../logger';
 
 const logger = new Logger('setup');

packages/hydrooj/src/entry/worker.ts

@@ -1,17 +1,16 @@
 /* eslint-disable no-await-in-loop */
-/* eslint-disable import/no-dynamic-require */
 import os from 'os';
-import fs from 'fs-extra';
 import path from 'path';
 import cac from 'cac';
-import {
-    locale, template, lib, service, model, handler, script, setting, uistatic,
-    builtinLib, builtinScript, builtinHandler, builtinModel,
-} from './common';
+import fs from 'fs-extra';
+import { Logger } from '../logger';
 import options from '../options';
 import * as bus from '../service/bus';
 import db from '../service/db';
-import { Logger } from '../logger';
+import {
+    builtinHandler, builtinLib, builtinModel,
+    builtinScript, handler, lib, locale, model, script, service, setting, template, uistatic,
+} from './common';
 
 const logger = new Logger('loader/worker');
 const detail = cac().parse().options.loaderDetail;

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!'],

packages/hydrooj/src/interface.ts

@@ -1,9 +1,9 @@
-import { ItemBucketMetadata } from 'minio';
-import type { Readable, Writable } from 'stream';
-import type { Cursor, ObjectID } from 'mongodb';
 import type fs from 'fs';
-import type { Dictionary, NumericDictionary } from 'lodash';
 import type * as Koa from 'koa';
+import type { Dictionary, NumericDictionary } from 'lodash';
+import type { ItemBucketMetadata } from 'minio';
+import type { Cursor, ObjectID } from 'mongodb';
+import type { Readable, Writable } from 'stream';
 import type { ProblemDoc } from './model/problem';
 
 type document = typeof import('./model/document');

packages/hydrooj/src/lib/download.ts

@@ -1,5 +1,5 @@
-import superagent, { SuperAgentRequest } from 'superagent';
 import fs from 'fs';
+import superagent, { SuperAgentRequest } from 'superagent';
 
 async function _download(url: string, path: string, retry: number) {
     const w = fs.createWriteStream(path);

packages/hydrooj/src/lib/misc.ts

@@ -1,6 +1,6 @@
 import AnsiUp from 'ansi_up';
 import { ObjectID } from 'mongodb';
-import { size, formatSeconds } from '@hydrooj/utils/lib/utils';
+import { formatSeconds, size } from '@hydrooj/utils/lib/utils';
 
 export { size, formatSeconds } from '@hydrooj/utils/lib/utils';
 

packages/hydrooj/src/lib/testdataConfig.ts

@@ -1,5 +1,5 @@
-import readYamlCases from '@hydrooj/utils/lib/cases';
 import { load } from 'js-yaml';
+import readYamlCases from '@hydrooj/utils/lib/cases';
 import type { ProblemConfig, ProblemConfigFile } from '../interface';
 
 export async function parseConfig(config: string | ProblemConfigFile = {}) {

packages/hydrooj/src/loader.ts

@@ -1,4 +1,4 @@
-/* eslint-disable import/no-dynamic-require */
+/* eslint-disable simple-import-sort/imports */
 /* eslint-disable no-await-in-loop */
 /* eslint-disable no-eval */
 import 'reflect-metadata';
@@ -50,6 +50,6 @@ export async function load() {
 }
 
 export async function loadCli() {
-    require('./entry/cli').load();
+    await require('./entry/cli').load();
     process.kill(process.pid, 'SIGINT');
 }

packages/hydrooj/src/logger.ts

@@ -1,5 +1,5 @@
-import { nanoid } from 'nanoid';
 import { format, inspect, InspectOptions } from 'util';
+import { nanoid } from 'nanoid';
 
 const colors = [
     20, 21, 26, 27, 32, 33, 38, 39, 40, 41, 42, 43, 44, 45, 56, 57, 62,

packages/hydrooj/src/model/blacklist.ts

@@ -1,7 +1,7 @@
 import moment from 'moment';
-import { ArgMethod } from '../utils';
-import db from '../service/db';
 import * as bus from '../service/bus';
+import db from '../service/db';
+import { ArgMethod } from '../utils';
 
 const coll = db.collection('blacklist');
 

packages/hydrooj/src/model/builtin.ts

@@ -7,10 +7,10 @@
  * e.g.: object?.property
  */
 import {
-    STATUS, STATUS_TEXTS, STATUS_CODES,
-    USER_GENDER_MALE, USER_GENDER_FEMALE, USER_GENDER_OTHER,
-    USER_GENDER_ICONS, USER_GENDERS, USER_GENDER_RANGE,
-} from '@hydrooj/utils/lib/status';
+    STATUS, STATUS_CODES,
+    STATUS_TEXTS, USER_GENDER_FEMALE,     USER_GENDER_ICONS,     USER_GENDER_MALE, USER_GENDER_OTHER,
+    USER_GENDER_RANGE,
+    USER_GENDERS } from '@hydrooj/utils/lib/status';
 
 export * from '@hydrooj/utils/lib/status';
 

packages/hydrooj/src/model/contest.ts

@@ -1,20 +1,20 @@
-import { ObjectID, FilterQuery } from 'mongodb';
-import user from './user';
-import problem from './problem';
-import * as document from './document';
-import { PERM, STATUS } from './builtin';
+import { FilterQuery, ObjectID } from 'mongodb';
 import {
-    ValidationError, ContestNotFoundError, ContestAlreadyAttendedError,
-    ContestNotAttendedError, ContestScoreboardHiddenError,
-} from '../error';
+    ContestAlreadyAttendedError,
+    ContestNotAttendedError, ContestNotFoundError, ContestScoreboardHiddenError,
+    ValidationError } from '../error';
 import {
-    ProblemId, ContestRule, ContestRules, ProblemDict,
-    ScoreboardNode, ScoreboardRow, Tdoc,
+    ContestRule, ContestRules, ProblemDict,
+    ProblemId,     ScoreboardNode, ScoreboardRow, Tdoc,
     Udict,
 } from '../interface';
-import * as bus from '../service/bus';
 import * as misc from '../lib/misc';
 import ranked from '../lib/rank';
+import * as bus from '../service/bus';
+import { PERM, STATUS } from './builtin';
+import * as document from './document';
+import problem from './problem';
+import user from './user';
 
 type Type = 30 | 60;
 

packages/hydrooj/src/model/discussion.ts

@@ -1,16 +1,16 @@
-import { FilterQuery, ObjectID } from 'mongodb';
 import { omit } from 'lodash';
 import moment from 'moment';
-import problem from './problem';
-import * as contest from './contest';
-import * as training from './training';
-import * as document from './document';
-import TaskModel from './task';
+import { FilterQuery, ObjectID } from 'mongodb';
 import { DiscussionNodeNotFoundError, DocumentNotFoundError } from '../error';
 import { DiscussionReplyDoc, DiscussionTailReplyDoc, Document } from '../interface';
-import { buildProjection } from '../utils';
-import { NumberKeys } from '../typeutils';
 import * as bus from '../service/bus';
+import { NumberKeys } from '../typeutils';
+import { buildProjection } from '../utils';
+import * as contest from './contest';
+import * as document from './document';
+import problem from './problem';
+import TaskModel from './task';
+import * as training from './training';
 
 export interface DiscussionDoc extends Document { }
 export namespace DiscussionDoc {

packages/hydrooj/src/model/document.ts

@@ -1,16 +1,16 @@
 /* eslint-disable object-curly-newline */
 import assert from 'assert';
 import {
-    ObjectID, Cursor, FilterQuery, UpdateQuery, OnlyFieldsOfType,
-} from 'mongodb';
+    Cursor, FilterQuery,     ObjectID, OnlyFieldsOfType,
+    UpdateQuery } from 'mongodb';
 import {
-    ProblemDoc, DiscussionDoc, DiscussionReplyDoc, Tdoc, TrainingDoc,
-    ProblemStatusDoc, Content,
+    Content,
+    DiscussionDoc, DiscussionReplyDoc,     ProblemDoc,     ProblemStatusDoc, Tdoc, TrainingDoc,
 } from '../interface';
-import { buildProjection } from '../utils';
-import { NumberKeys, ArrayKeys, Projection, MaybeArray } from '../typeutils';
-import db from '../service/db';
 import * as bus from '../service/bus';
+import db from '../service/db';
+import { ArrayKeys, MaybeArray, NumberKeys, Projection } from '../typeutils';
+import { buildProjection } from '../utils';
 
 type DocID = ObjectID | string | number;
 
@@ -234,7 +234,7 @@ export async function setSub<T extends keyof DocType, K extends ArrayKeys<DocTyp
     domainId: string, docType: T, docId: DocType[T]['docId'],
     key: K, subId: DocType[T][K][0]['_id'], args: Partial<DocType[T][K][0]>,
 ): Promise<DocType[T]> {
-    const $set = {};
+    const $set: Record<string, any> = {};
     for (const k in args) $set[`${key}.$.${k}`] = args[k];
     const res = await coll.findOneAndUpdate(
         {

packages/hydrooj/src/model/domain.ts

@@ -1,11 +1,11 @@
 import { Dictionary } from 'lodash';
 import { FilterQuery } from 'mongodb';
-import { BUILTIN_ROLES, PRIV } from './builtin';
 import { DomainDoc } from '../interface';
-import { ArgMethod } from '../utils';
-import { MaybeArray, NumberKeys } from '../typeutils';
 import * as bus from '../service/bus';
 import db from '../service/db';
+import { MaybeArray, NumberKeys } from '../typeutils';
+import { ArgMethod } from '../utils';
+import { BUILTIN_ROLES, PRIV } from './builtin';
 import UserModel, { deleteUserCache } from './user';
 
 const coll = db.collection('domain');

packages/hydrooj/src/model/message.ts

@@ -1,9 +1,9 @@
 import { FilterQuery, ObjectID } from 'mongodb';
-import user from './user';
 import { MessageDoc } from '../interface';
-import { ArgMethod } from '../utils';
-import db from '../service/db';
 import * as bus from '../service/bus';
+import db from '../service/db';
+import { ArgMethod } from '../utils';
+import user from './user';
 
 const coll = db.collection('message');
 

packages/hydrooj/src/model/problem.ts

@@ -1,23 +1,23 @@
-import { ObjectID, FilterQuery } from 'mongodb';
 import {
     Dictionary, escapeRegExp, flatten, groupBy, pick,
 } from 'lodash';
-import { streamToBuffer } from '@hydrooj/utils/lib/utils';
+import { FilterQuery, ObjectID } from 'mongodb';
 import type { Readable } from 'stream';
-import * as document from './document';
-import { STATUS } from './builtin';
-import domain from './domain';
-import storage from './storage';
-import { buildProjection } from '../utils';
+import { streamToBuffer } from '@hydrooj/utils/lib/utils';
+import { ProblemNotFoundError, ValidationError } from '../error';
 import type {
-    ProblemStatusDoc, ProblemDict, Document, ProblemId, DomainDoc,
-} from '../interface';
+    Document, DomainDoc,
+    ProblemDict, ProblemId,     ProblemStatusDoc } from '../interface';
+import { parseConfig } from '../lib/testdataConfig';
+import * as bus from '../service/bus';
 import {
     ArrayKeys, MaybeArray, NumberKeys, Projection,
 } from '../typeutils';
-import { ProblemNotFoundError, ValidationError } from '../error';
-import * as bus from '../service/bus';
-import { parseConfig } from '../lib/testdataConfig';
+import { buildProjection } from '../utils';
+import { STATUS } from './builtin';
+import * as document from './document';
+import domain from './domain';
+import storage from './storage';
 
 export interface ProblemDoc extends Document { }
 export type Field = keyof ProblemDoc;

packages/hydrooj/src/model/record.ts

@@ -1,22 +1,22 @@
 /* eslint-disable object-curly-newline */
-import {
-    ObjectID, Collection, UpdateQuery,
-    PushOperator, MatchKeysAndValues, OnlyFieldsOfType,
-    FilterQuery,
-} from 'mongodb';
 import { omit, sum } from 'lodash';
 import moment from 'moment';
-import { STATUS } from './builtin';
-import task from './task';
-import problem from './problem';
 import {
-    RecordDoc, ContestInfo, ProblemConfigFile, ExternalProblemId, FileInfo,
-} from '../interface';
+    Collection,     FilterQuery,
+    MatchKeysAndValues,     ObjectID, OnlyFieldsOfType,
+    PushOperator, UpdateQuery,
+} from 'mongodb';
 import { ProblemNotFoundError } from '../error';
-import { ArgMethod, buildProjection, Time } from '../utils';
-import { MaybeArray } from '../typeutils';
+import {
+    ContestInfo, ExternalProblemId, FileInfo,
+    ProblemConfigFile,     RecordDoc } from '../interface';
 import * as bus from '../service/bus';
 import db from '../service/db';
+import { MaybeArray } from '../typeutils';
+import { ArgMethod, buildProjection, Time } from '../utils';
+import { STATUS } from './builtin';
+import problem from './problem';
+import task from './task';
 
 class RecordModel {
     static coll: Collection<RecordDoc> = db.collection('record');

packages/hydrooj/src/model/setting.ts

@@ -1,14 +1,14 @@
 /* eslint-disable max-len */
 /* eslint-disable no-await-in-loop */
-import moment from 'moment-timezone';
-import { Dictionary } from 'lodash';
 import yaml from 'js-yaml';
-import { retry } from '@hydrooj/utils/lib/utils';
+import { Dictionary } from 'lodash';
+import moment from 'moment-timezone';
 import { parseLang } from '@hydrooj/utils/lib/lang';
-import * as builtin from './builtin';
+import { retry } from '@hydrooj/utils/lib/utils';
 import { Setting as _Setting } from '../interface';
 import { Logger } from '../logger';
 import * as bus from '../service/bus';
+import * as builtin from './builtin';
 
 type SettingDict = Dictionary<_Setting>;
 
@@ -208,7 +208,6 @@ SystemSetting(
     Setting('setting_storage', 'installid', String.random(64), 'text', 'installid', 'Installation ID', FLAG_HIDDEN | FLAG_DISABLED),
 );
 
-// eslint-disable-next-line import/no-mutable-exports
 export let langs = {};
 
 bus.once('app/started', async () => {

packages/hydrooj/src/model/solution.ts

@@ -1,7 +1,7 @@
 import { ObjectID } from 'mongodb';
-import * as document from './document';
 import { SolutionNotFoundError } from '../error';
 import * as bus from '../service/bus';
+import * as document from './document';
 
 class SolutionModel {
     static add(domainId: string, pid: number, owner: number, content: string) {

packages/hydrooj/src/model/storage.ts

@@ -1,14 +1,14 @@
-import { escapeRegExp } from 'lodash';
-import { ItemBucketMetadata } from 'minio';
-import { nanoid } from 'nanoid';
-import { lookup } from 'mime-types';
-import moment from 'moment';
 import { extname } from 'path';
+import { escapeRegExp } from 'lodash';
+import { lookup } from 'mime-types';
+import { ItemBucketMetadata } from 'minio';
+import moment from 'moment';
+import { nanoid } from 'nanoid';
 import type { Readable } from 'stream';
-import TaskModel from './task';
-import storage from '../service/storage';
 import * as bus from '../service/bus';
 import db from '../service/db';
+import storage from '../service/storage';
+import TaskModel from './task';
 
 export class StorageModel {
     static coll = db.collection('storage');

packages/hydrooj/src/model/system.ts

@@ -1,8 +1,8 @@
-import { SYSTEM_SETTINGS } from './setting';
-import { NumberKeys } from '../typeutils';
 import { SystemKeys } from '../interface';
-import db from '../service/db';
 import * as bus from '../service/bus';
+import db from '../service/db';
+import { NumberKeys } from '../typeutils';
+import { SYSTEM_SETTINGS } from './setting';
 
 const coll = db.collection('system');
 const cache: Record<string, any> = {};

packages/hydrooj/src/model/task.ts

@@ -1,11 +1,11 @@
-import moment from 'moment-timezone';
 import { hostname } from 'os';
+import moment from 'moment-timezone';
 import { FilterQuery, ObjectID } from 'mongodb';
 import { sleep } from '@hydrooj/utils/lib/utils';
 import { BaseService, Task } from '../interface';
 import { Logger } from '../logger';
-import db from '../service/db';
 import * as bus from '../service/bus';
+import db from '../service/db';
 
 const logger = new Logger('model/task');
 const coll = db.collection('task');

packages/hydrooj/src/model/token.ts

@@ -1,8 +1,8 @@
 import { FilterQuery } from 'mongodb';
-import { ArgMethod } from '../utils';
 import { TokenDoc } from '../interface';
-import db from '../service/db';
 import * as bus from '../service/bus';
+import db from '../service/db';
+import { ArgMethod } from '../utils';
 
 class TokenModel {
     static coll = db.collection('token');

packages/hydrooj/src/model/training.ts

@@ -1,8 +1,8 @@
-import { FilterQuery, ObjectID } from 'mongodb';
 import { flatten } from 'lodash';
-import * as document from './document';
-import { TrainingNotFoundError, TrainingAlreadyEnrollError } from '../error';
+import { FilterQuery, ObjectID } from 'mongodb';
+import { TrainingAlreadyEnrollError, TrainingNotFoundError } from '../error';
 import { TrainingDoc, TrainingNode } from '../interface';
+import * as document from './document';
 
 export function getStatus(domainId: string, tid: ObjectID, uid: number) {
     return document.getStatus(domainId, document.TYPE_TRAINING, tid, uid);

packages/hydrooj/src/model/user.ts

@@ -1,21 +1,21 @@
-import { Collection } from 'mongodb';
-import LRU from 'lru-cache';
 import { escapeRegExp, pick } from 'lodash';
+import LRU from 'lru-cache';
+import { Collection } from 'mongodb';
+import { LoginError, UserAlreadyExistError, UserNotFoundError } from '../error';
+import {
+    FileInfo,
+    Udict, Udoc,     User as _User } from '../interface';
+import pwhash from '../lib/hash.hydro';
+import { Logger } from '../logger';
+import * as bus from '../service/bus';
+import db from '../service/db';
+import { Value } from '../typeutils';
+import { ArgMethod } from '../utils';
+import { PERM, PRIV } from './builtin';
+import domain from './domain';
+import * as setting from './setting';
 import * as system from './system';
 import token from './token';
-import * as setting from './setting';
-import domain from './domain';
-import { PERM, PRIV } from './builtin';
-import { ArgMethod } from '../utils';
-import { UserNotFoundError, UserAlreadyExistError, LoginError } from '../error';
-import {
-    User as _User, Udoc, Udict, FileInfo,
-} from '../interface';
-import { Value } from '../typeutils';
-import { Logger } from '../logger';
-import pwhash from '../lib/hash.hydro';
-import db from '../service/db';
-import * as bus from '../service/bus';
 
 const coll: Collection<Udoc> = db.collection('user');
 const logger = new Logger('model/user');

packages/hydrooj/src/pipelineUtils.ts

@@ -1,13 +1,14 @@
 /* eslint-disable no-await-in-loop */
 import { FilterQuery } from 'mongodb';
 import type {
-    DomainDoc, Udoc, ProblemStatusDoc, RecordDoc,
+    DomainDoc, ProblemStatusDoc, RecordDoc,
+    Udoc,
 } from './interface';
-import domain from './model/domain';
 import * as document from './model/document';
-import user from './model/user';
+import domain from './model/domain';
 import problem, { Field, ProblemDoc } from './model/problem';
 import RecordModel from './model/record';
+import user from './model/user';
 
 export async function iterateAllDomain(cb: (ddoc: DomainDoc, current?: number, total?: number) => Promise<any>) {
     const ddocs = await domain.getMulti().toArray();

packages/hydrooj/src/script/blacklist.ts

@@ -1,9 +1,9 @@
 /* eslint-disable @typescript-eslint/no-use-before-define */
 import { ObjectID } from 'mongodb';
-import * as document from '../model/document';
-import * as discussion from '../model/discussion';
-import user from '../model/user';
 import blacklist from '../model/blacklist';
+import * as discussion from '../model/discussion';
+import * as document from '../model/document';
+import user from '../model/user';
 import db from '../service/db';
 
 export const description = 'Add blacklist by ip, uid';

packages/hydrooj/src/script/deleteUser.ts

@@ -1,6 +1,6 @@
+import { PRIV } from '../model/builtin';
 import user from '../model/user';
 import db from '../service/db';
-import { PRIV } from '../model/builtin';
 
 export const description = 'Delete a user';
 

packages/hydrooj/src/script/problemStat.ts

@@ -1,7 +1,7 @@
 /* eslint-disable no-await-in-loop */
-import db from '../service/db';
 import { STATUS } from '../model/builtin';
 import * as document from '../model/document';
+import db from '../service/db';
 
 export const description = 'Recalculates nSubmit and nAccept in problem status.';
 

packages/hydrooj/src/script/rating.ts

@@ -1,16 +1,16 @@
 /* eslint-disable no-await-in-loop */
-import { unionWith, NumericDictionary } from 'lodash';
-import { ObjectID, FilterQuery } from 'mongodb';
-import { Tdoc, ProblemDoc, Udoc } from '../interface';
-import db from '../service/db';
-import domain from '../model/domain';
-import * as contest from '../model/contest';
-import problem from '../model/problem';
-import UserModel from '../model/user';
-import record from '../model/record';
-import { PRIV, STATUS } from '../model/builtin';
-import rating from '../lib/rating';
+import { NumericDictionary, unionWith } from 'lodash';
+import { FilterQuery, ObjectID } from 'mongodb';
+import { ProblemDoc, Tdoc, Udoc } from '../interface';
 import paginate from '../lib/paginate';
+import rating from '../lib/rating';
+import { PRIV, STATUS } from '../model/builtin';
+import * as contest from '../model/contest';
+import domain from '../model/domain';
+import problem from '../model/problem';
+import record from '../model/record';
+import UserModel from '../model/user';
+import db from '../service/db';
 
 export const description = 'Calculate rp of a domain, or all domains';
 

packages/hydrooj/src/service/__mocks__/db.ts

@@ -1,7 +1,7 @@
 // @ts-nocheck
 import { Collection, Db, MongoClient } from 'mongodb';
+import { BaseService, Collections } from '../../interface';
 import * as bus from '../bus';
-import { Collections, BaseService } from '../../interface';
 
 interface MongoConfig {
     protocol?: string,

packages/hydrooj/src/service/bus.ts

@@ -3,16 +3,16 @@ import cac from 'cac';
 import type {
     Db, FilterQuery, ObjectID, OnlyFieldsOfType,
 } from 'mongodb';
-import type { Handler } from './server';
-import { Logger } from '../logger';
-import type {
-    MessageDoc, ProblemDoc, RecordDoc,
-    TrainingDoc, User, DiscussionDoc,
-    DomainDoc, FileInfo, Tdoc,
-} from '../interface';
-import type { DocType } from '../model/document';
 import type { ProblemSolutionHandler } from '../handler/problem';
 import type { UserRegisterHandler } from '../handler/user';
+import type {
+    DiscussionDoc,
+    DomainDoc, FileInfo,     MessageDoc, ProblemDoc, RecordDoc,
+    Tdoc,
+    TrainingDoc, User } from '../interface';
+import { Logger } from '../logger';
+import type { DocType } from '../model/document';
+import type { Handler } from './server';
 
 const _hooks: Record<keyof any, Array<(...args: any[]) => any>> = {};
 const logger = new Logger('bus');

packages/hydrooj/src/service/db.ts

@@ -1,6 +1,6 @@
 import { Collection, Db, MongoClient } from 'mongodb';
+import { BaseService, Collections } from '../interface';
 import * as bus from './bus';
-import { Collections, BaseService } from '../interface';
 
 interface MongoConfig {
     protocol?: string,

packages/hydrooj/src/service/monitor.ts

@@ -1,11 +1,11 @@
 import crypto from 'crypto';
-import superagent from 'superagent';
 import { dump } from 'js-yaml';
-import * as sysinfo from '@hydrooj/utils/lib/sysinfo';
+import superagent from 'superagent';
 import type { StatusUpdate } from '@hydrooj/utils/lib/sysinfo';
-import db from './db';
-import * as bus from './bus';
+import * as sysinfo from '@hydrooj/utils/lib/sysinfo';
 import { Logger } from '../logger';
+import * as bus from './bus';
+import db from './db';
 
 const coll = db.collection('status');
 const logger = new Logger('monitor');

packages/hydrooj/src/service/server.ts

@@ -1,43 +1,43 @@
 import assert from 'assert';
-import { PassThrough } from 'stream';
-import { resolve } from 'path';
-import os from 'os';
+import { createHash } from 'crypto';
 import http from 'http';
-import moment from 'moment-timezone';
-import {
-    isSafeInteger, Dictionary, filter, cloneDeep,
-} from 'lodash';
-import { ObjectID } from 'mongodb';
+import os from 'os';
+import { resolve } from 'path';
+import { PassThrough } from 'stream';
+import cac from 'cac';
+import Cookies from 'cookies';
 import Koa, { Context } from 'koa';
 import Body from 'koa-body';
 import Compress from 'koa-compress';
-import Router from 'koa-router';
 import proxy from 'koa-proxies';
+import Router from 'koa-router';
 import cache from 'koa-static-cache';
-import sockjs from 'sockjs';
-import cac from 'cac';
-import { createHash } from 'crypto';
-import { parseMemoryMB } from '@hydrooj/utils/lib/utils';
-import Cookies from 'cookies';
-import * as bus from './bus';
-import { errorMessage } from '../utils';
-import { User, DomainDoc } from '../interface';
-import { Logger } from '../logger';
 import {
-    UserNotFoundError, BlacklistedError, PermissionError,
-    UserFacingError, ValidationError, PrivilegeError,
-    CsrfTokenError, InvalidOperationError, MethodNotAllowedError,
-    NotFoundError, HydroError, SystemError,
-} from '../error';
-import { isContent, isName, isTitle } from '../lib/validator';
+    cloneDeep,
+    Dictionary, filter,     isSafeInteger } from 'lodash';
+import moment from 'moment-timezone';
+import { ObjectID } from 'mongodb';
+import sockjs from 'sockjs';
+import { parseMemoryMB } from '@hydrooj/utils/lib/utils';
+import {
+    BlacklistedError,     CsrfTokenError, HydroError, InvalidOperationError, MethodNotAllowedError,
+    NotFoundError, PermissionError,
+    PrivilegeError,
+    SystemError,
+    UserFacingError,     UserNotFoundError, ValidationError } from '../error';
+import { DomainDoc, User } from '../interface';
 import avatar from '../lib/avatar';
-import user from '../model/user';
-import domain from '../model/domain';
-import * as system from '../model/system';
+import { isContent, isName, isTitle } from '../lib/validator';
+import { Logger } from '../logger';
 import blacklist from '../model/blacklist';
-import token from '../model/token';
-import * as opcount from '../model/opcount';
 import { PERM, PRIV } from '../model/builtin';
+import domain from '../model/domain';
+import * as opcount from '../model/opcount';
+import * as system from '../model/system';
+import token from '../model/token';
+import user from '../model/user';
+import { errorMessage } from '../utils';
+import * as bus from './bus';
 
 const argv = cac().parse();
 const logger = new Logger('server');
@@ -702,11 +702,15 @@ async function handle(ctx, HandlerClass, checker) {
         await bail('handler/init', h);
         await bail(`handler/before-prepare/${HandlerClass.name.replace(/Handler$/, '')}`, h);
         await bail('handler/before-prepare', h);
+        h.args.__prepare = Date.now();
         if (h._prepare) await h._prepare(args);
         if (h.prepare) await h.prepare(args);
+        h.args.__prepareDone = Date.now();
         await bail(`handler/before/${HandlerClass.name.replace(/Handler$/, '')}`, h);
         await bail('handler/before', h);
+        h.args.__method = Date.now();
         if (h[method]) await h[method](args);
+        h.args.__methodDone = Date.now();
         await bail(`handler/before-operation/${HandlerClass.name.replace(/Handler$/, '')}`, h);
         await bail('handler/before-operation', h);
         if (operation) await h[`post${operation}`](args);

packages/hydrooj/src/service/storage.ts

@@ -1,11 +1,11 @@
-import { Readable } from 'stream';
 import assert from 'assert';
+import { Readable } from 'stream';
 import { URL } from 'url';
-import { Client, BucketItem, ItemBucketMetadata } from 'minio';
 import { createReadStream } from 'fs-extra';
+import { BucketItem, Client, ItemBucketMetadata } from 'minio';
 import { Logger } from '../logger';
-import { streamToBuffer } from '../utils';
 import * as system from '../model/system';
+import { streamToBuffer } from '../utils';
 
 const logger = new Logger('storage');
 

packages/hydrooj/src/typedoc.entry.ts

@@ -1,23 +1,23 @@
 import * as interfaces from './interface';
-import * as document from './model/document';
-import user from './model/user';
-import domain from './model/domain';
-import problem from './model/problem';
-import record from './model/record';
-import task from './model/task';
-import * as training from './model/training';
 import blacklist from './model/blacklist';
 import * as builtin from './model/builtin';
+import * as contest from './model/contest';
+import * as discussion from './model/discussion';
+import * as document from './model/document';
+import domain from './model/domain';
+import message from './model/message';
 import oauth from './model/oauth';
+import * as opcount from './model/opcount';
 import * as oplog from './model/oplog';
-import * as system from './model/system';
+import problem from './model/problem';
+import record from './model/record';
 import * as setting from './model/setting';
 import solution from './model/solution';
+import * as system from './model/system';
+import task from './model/task';
 import token from './model/token';
-import message from './model/message';
-import * as discussion from './model/discussion';
-import * as contest from './model/contest';
-import * as opcount from './model/opcount';
+import * as training from './model/training';
+import user from './model/user';
 
 export const Interface = interfaces;
 

packages/hydrooj/src/upgrade.ts

@@ -1,34 +1,34 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 /* eslint-disable no-await-in-loop */
-import { ObjectID, GridFSBucket } from 'mongodb';
 import AdmZip from 'adm-zip';
-import Queue from 'p-queue';
 import yaml from 'js-yaml';
 import { pick } from 'lodash';
-import { convertIniConfig } from '@hydrooj/utils/lib/cases';
 import { BucketItem } from 'minio';
 import moment from 'moment';
-import db from './service/db';
-import { Progress } from './ui';
+import { GridFSBucket, ObjectID } from 'mongodb';
+import Queue from 'p-queue';
+import { convertIniConfig } from '@hydrooj/utils/lib/cases';
+import { buildContent } from './lib/content';
+import difficultyAlgorithm from './lib/difficulty';
+import { size } from './lib/misc';
 import { Logger } from './logger';
-import { streamToBuffer } from './utils';
+import { PRIV, STATUS } from './model/builtin';
+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 RecordModel from './model/record';
+import StorageModel from './model/storage';
+import * as system from './model/system';
+import user from './model/user';
 import {
     iterateAllDomain, iterateAllProblem, iterateAllPsdoc, iterateAllUser,
 } from './pipelineUtils';
+import db from './service/db';
 import storage from './service/storage';
-import difficultyAlgorithm from './lib/difficulty';
-import problem from './model/problem';
-import user from './model/user';
-import * as contest from './model/contest';
-import * as discussion from './model/discussion';
-import domain from './model/domain';
-import * as document from './model/document';
-import * as system from './model/system';
-import { PRIV, STATUS } from './model/builtin';
-import RecordModel from './model/record';
-import StorageModel from './model/storage';
-import { size } from './lib/misc';
-import { buildContent } from './lib/content';
+import { Progress } from './ui';
+import { streamToBuffer } from './utils';
 
 const logger = new Logger('upgrade');
 type UpgradeScript = void | (() => Promise<boolean | void>);

packages/hydrooj/test/db.ts

@@ -1,4 +1,5 @@
 import 'hydrooj/src/loader';
+
 import * as bus from 'hydrooj/src/service/bus';
 
 jest.mock('hydrooj/src/service/db');

packages/hydrooj/test/lib.crypto.spec.ts

@@ -1,4 +1,5 @@
 import 'hydrooj/src/loader';
+
 import { md5, sha1 } from 'hydrooj/src/lib/crypto';
 import pwhash from 'hydrooj/src/lib/hash.hydro';
 

packages/hydrooj/test/lib.validator.spec.ts

@@ -1,4 +1,5 @@
 import 'hydrooj/src/loader';
+
 import * as validator from 'hydrooj/src/lib/validator';
 
 describe('Validator', () => {

packages/hydrooj/test/model.problem.spec.ts

@@ -1,4 +1,5 @@
 import 'hydrooj/src/loader';
+
 import { connect, dispose } from './db';
 
 jest.setTimeout(30000);

packages/hydrooj/test/model.user.spec.ts

@@ -1,6 +1,7 @@
 import 'hydrooj/src/loader';
-import * as bus from 'hydrooj/src/service/bus';
+
 import { PRIV } from 'hydrooj/src/model/builtin';
+import * as bus from 'hydrooj/src/service/bus';
 import { connect, dispose } from './db';
 
 jest.setTimeout(30000);

packages/hydrooj/test/utils.spec.ts

@@ -1,4 +1,5 @@
 import 'hydrooj/src/loader';
+
 import * as utils from 'hydrooj/src/utils';
 
 describe('Utils', () => {

packages/import-qduoj/handler.ts

@@ -1,16 +1,16 @@
 /* eslint-disable no-await-in-loop */
-import path from 'path';
 import os from 'os';
-import fs from 'fs-extra';
+import path from 'path';
 import AdmZip from 'adm-zip';
+import fs from 'fs-extra';
 import yaml from 'js-yaml';
-import { Route, Handler } from 'hydrooj/src/service/server';
-import { ValidationError } from 'hydrooj/src/error';
-import { ProblemAdd } from 'hydrooj/src/lib/ui';
-import problem from 'hydrooj/src/model/problem';
-import { PERM } from 'hydrooj/src/model/builtin';
-import { buildContent } from 'hydrooj/src/lib/content';
 import type { ContentNode, ProblemConfigFile } from 'hydrooj';
+import { ValidationError } from 'hydrooj/src/error';
+import { buildContent } from 'hydrooj/src/lib/content';
+import { ProblemAdd } from 'hydrooj/src/lib/ui';
+import { PERM } from 'hydrooj/src/model/builtin';
+import problem from 'hydrooj/src/model/problem';
+import { Handler, Route } from 'hydrooj/src/service/server';
 
 fs.ensureDirSync('/tmp/hydro/import-qduoj');
 

packages/login-with-github/lib.ts

@@ -1,4 +1,5 @@
 import 'hydrooj';
+
 import * as superagent from 'superagent';
 
 declare module 'hydrooj' {

packages/login-with-google/lib.ts

@@ -1,4 +1,5 @@
 import 'hydrooj';
+
 import * as superagent from 'superagent';
 
 declare module 'hydrooj' {

packages/login-with-osu/lib.ts

@@ -1,4 +1,5 @@
 import 'hydrooj';
+
 import * as superagent from 'superagent';
 
 declare module 'hydrooj' {

packages/login-with-qq/package.json

@@ -7,7 +7,7 @@
     "license": "AGPL-3.0-or-later",
     "preferUnplugged": true,
     "dependencies": {
-        "ws": "^8.2.1"
+        "ws": "^8.2.2"
     },
     "devDependencies": {
         "@types/ws": "^7.4.7"

packages/login-with-qq/service.ts

@@ -1,6 +1,6 @@
+import WebSocket from 'ws';
 import { } from 'hydrooj';
 import * as bus from 'hydrooj/src/service/bus';
-import WebSocket from 'ws';
 
 declare module 'hydrooj' {
     interface SystemKeys {

packages/migrate-hustoj/script.ts

@@ -2,9 +2,9 @@
 /* eslint-disable no-await-in-loop */
 import mysql from 'mysql';
 import { buildContent } from 'hydrooj/src/lib/content';
-import user from 'hydrooj/src/model/user';
 import problem from 'hydrooj/src/model/problem';
 import * as system from 'hydrooj/src/model/system';
+import user from 'hydrooj/src/model/user';
 
 export async function run({
     host = 'localhost', port = 27017, name = 'vijos4', username, password,

packages/migrate-vijos/package.json

@@ -10,6 +10,6 @@
         "@types/mongodb": "^3.6.20"
     },
     "dependencies": {
-        "mongodb": "^3.6.12"
+        "mongodb": "^3.7.0"
     }
 }

packages/migrate-vijos/script.ts

@@ -1,8 +1,8 @@
 /* eslint-disable no-await-in-loop */
+import mongodb, { Cursor, Db } from 'mongodb';
 import {
-    RecordDoc, TestCase, MessageDoc, DiscussionTailReplyDoc, TrainingNode,
+    DiscussionTailReplyDoc, MessageDoc,     RecordDoc, TestCase, TrainingNode,
 } from 'hydrooj';
-import mongodb, { Db, Cursor } from 'mongodb';
 
 const dst = global.Hydro.service.db;
 const { discussion, document } = global.Hydro.model;

packages/onlyoffice/handler.ts

@@ -1,5 +1,5 @@
-import { UiContextBase } from 'hydrooj/src/service/server';
 import * as system from 'hydrooj/src/model/system';
+import { UiContextBase } from 'hydrooj/src/service/server';
 
 declare module 'hydrooj/src/service/server' {
     interface UiContextBase {

packages/recaptcha/handler.ts

@@ -1,5 +1,5 @@
 import superagent from 'superagent';
-import { ValidationError, ForbiddenError } from 'hydrooj/src/error';
+import { ForbiddenError, ValidationError } from 'hydrooj/src/error';
 import { PRIV } from 'hydrooj/src/model/builtin';
 import * as system from 'hydrooj/src/model/system';
 import * as bus from 'hydrooj/src/service/bus';

packages/sonic/model.ts

@@ -1,5 +1,5 @@
-import * as bus from 'hydrooj/src/service/bus';
 import * as system from 'hydrooj/src/model/system';
+import * as bus from 'hydrooj/src/service/bus';
 import sonic from './service';
 
 bus.on('problem/add', async (doc, docId) => {

packages/sonic/service.ts

@@ -1,9 +1,9 @@
-import { BaseService } from 'hydrooj';
-import * as system from 'hydrooj/src/model/system';
-import { Logger } from 'hydrooj/src/logger';
 import {
-    Search, Ingest, QueryOptions, SuggestOptions, PushOptions,
-} from 'sonic-channel';
+    Ingest, PushOptions,
+    QueryOptions,     Search, SuggestOptions } from 'sonic-channel';
+import { BaseService } from 'hydrooj';
+import { Logger } from 'hydrooj/src/logger';
+import * as system from 'hydrooj/src/model/system';
 
 const logger = new Logger('sonic');