core&ui: remove Hydro.service.bus, Hydro.ui.template

packages/hydrooj/src/entry/common.ts

@@ -14,17 +14,6 @@ import { unwrapExports } from '../utils';
 
 const logger = new Logger('common');
 
-async function getFiles(folder: string, base = ''): Promise<string[]> {
-    const files = [];
-    const f = await fs.readdir(folder);
-    for (const i of f) {
-        if ((await fs.stat(path.join(folder, i))).isDirectory()) {
-            files.push(...await getFiles(path.join(folder, i), path.join(base, i)));
-        } else files.push(path.join(base, i));
-    }
-    return files.map((item) => item.replace(/\\/gmi, '/'));
-}
-
 function locateFile(basePath: string, filenames: string[]) {
     for (const i of filenames) {
         const p = path.resolve(basePath, i);
@@ -136,26 +125,3 @@ export async function setting(pending: string[], fail: string[], modelSetting: t
         }
     }
 }
-
-export async function template(pending: string[], fail: string[]) {
-    for (const i of pending) {
-        const p = locateFile(i, ['template', 'templates']);
-        if (p && (await fs.stat(p)).isDirectory() && !fail.includes(i)) {
-            try {
-                const files = await getFiles(p);
-                for (const file of files) {
-                    const l = path.resolve(p, file);
-                    if (file.endsWith('.tsx')) global.Hydro.ui.template[file] = require(l);
-                    global.Hydro.ui.template[file] = await fs.readFile(l, 'utf-8');
-                    if (process.env.DEV) global.Hydro.ui.template[`${file}.source`] = l;
-                }
-                logger.info('Template init: %s', i);
-            } catch (e) {
-                fail.push(i);
-                app.injectUI('Notification', 'Template load fail: {0}', { args: [i], type: 'warn' }, PRIV.PRIV_VIEW_SYSTEM_NOTIFICATION);
-                logger.error('Template Load Fail: %s', i);
-                logger.error(e);
-            }
-        }
-    }
-}

packages/hydrooj/src/entry/worker.ts

@@ -30,10 +30,7 @@ export async function apply(ctx: Context) {
     }
     const pending = global.addons;
     const fail = [];
-    await Promise.all([
+    await locale(pending, fail);
-        locale(pending, fail),
-        template(pending, fail),
-    ]);
     await ctx.plugin(MongoService, load() || {});
     await ctx.plugin(ConfigService);
     const modelSystem = require('../model/system');

packages/hydrooj/src/init.ts

@@ -9,8 +9,6 @@ if (!global.Hydro) {
             hydrooj: require('hydrooj/package.json').version,
         },
         // @ts-ignore
-        service: {},
-        // @ts-ignore
         model: {},
         script: {},
         // @ts-ignore
@@ -22,9 +20,7 @@ if (!global.Hydro) {
             },
         }),
         // @ts-ignore
-        ui: {
+        ui: {},
-            template: {},
-        },
         // @ts-ignore
         error: {},
         locales: {},

packages/hydrooj/src/interface.ts

@@ -596,11 +596,6 @@ export interface Model {
     rp: typeof import('./script/rating').RpTypes,
 }
 
-export interface HydroService {
-    /** @deprecated */
-    bus: Context,
-}
-
 export interface GeoIP {
     provider: string,
     lookup: (ip: string, locale?: string) => any,
@@ -629,7 +624,6 @@ export interface Lib extends Record<string, any> {
 
 export type UIInjectableFields = 'ProblemAdd' | 'Notification' | 'Nav' | 'UserDropdown' | 'DomainManage' | 'ControlPanel';
 export interface UI {
-    template: Record<string, string>,
     nodes: Record<UIInjectableFields, any[]>,
     getNodes: typeof import('./lib/ui').getNodes,
     inject: typeof import('./lib/ui').inject,
@@ -650,7 +644,6 @@ export interface HydroGlobal {
     version: Record<string, string>;
     model: Model;
     script: Record<string, Script>;
-    service: HydroService;
     lib: Lib;
     module: { [K in keyof ModuleInterfaces]: Record<string, ModuleInterfaces[K]> };
     ui: UI;

packages/hydrooj/src/service/bus.ts

@@ -115,5 +115,4 @@ export function apply(ctx: Context) {
 
 export default app;
 
-global.Hydro.service.bus = app as any;
 global.bus = app;

packages/hydrooj/src/service/server.ts

@@ -238,12 +238,6 @@ export async function apply(ctx: Context) {
             h.translate = h.translate.bind(h);
             h.url = h.url.bind(h);
             h.ctx = h.ctx.extend({ domain: h.domain });
-            h.renderHTML = ((orig) => function (name: string, args: Record<string, any>) {
-                const s = name.split('.');
-                let templateName = `${s[0]}.${args.domainId}.${s[1]}`;
-                if (!global.Hydro.ui.template[templateName]) templateName = name;
-                return orig(templateName, args);
-            })(h.renderHTML).bind(h);
         });
         on('handler/create/http', async (h) => {
             if (!argv.options.benchmark && !h.notUsage) await h.limitRate('global', 5, 100);

packages/ui-default/backendlib/template.ts

@@ -2,7 +2,7 @@ import * as status from '@hydrooj/common/status';
 import { findFileSync } from '@hydrooj/utils/lib/utils';
 import { convert } from 'html-to-text';
 import {
-  avatar, Context, fs, PERM, PRIV, STATUS, yaml,
+  avatar, Context, fs, PERM, PRIV, Service, STATUS, yaml,
 } from 'hydrooj';
 import jsesc from 'jsesc';
 import nunjucks from 'nunjucks';
@@ -16,48 +16,47 @@ let { template } = argv.options;
 if (!template || typeof template !== 'string') template = findFileSync('@hydrooj/ui-default/templates');
 else template = findFileSync(template);
 
-class Loader extends nunjucks.Loader {
-  getSource(name) {
-    const src = global.Hydro.ui.template[name];
-    const ref = global.Hydro.ui.template[`${name}.source`];
-    if (!process.env.DEV) {
-      if (!src) throw new Error(`Cannot get template ${name}`);
-      return {
-        src,
-        path: name,
-        noCache: false,
-      };
-    }
-    let fullpath = null;
-    const p = path.resolve(template, name);
-    if (fs.existsSync(p)) fullpath = p;
-    if (!fullpath && ref && fs.existsSync(ref)) fullpath = ref;
-    if (!fullpath) {
-      if (src) {
-        return {
-          src,
-          path: name,
-          noCache: true,
-        };
-      }
-      throw new Error(`Cannot get template ${name}`);
-    }
-    return {
-      src: fs.readFileSync(fullpath, 'utf-8'),
-      path: fullpath,
-      noCache: true,
-    };
-  }
-}
-
 const replacer = (k, v) => {
   if (k.startsWith('_') && k !== '_id') return undefined;
   if (typeof v === 'bigint') return `BigInt::${v.toString()}`;
   return v;
 };
 
+async function getFiles(folder: string, base = ''): Promise<string[]> {
+  const files: string[] = [];
+  const f = await fs.readdir(folder);
+  for (const i of f) {
+    if ((await fs.stat(path.join(folder, i))).isDirectory()) {
+      files.push(...await getFiles(path.join(folder, i), path.join(base, i)));
+    } else files.push(path.join(base, i));
+  }
+  return files.map((item) => item.replace(/\\/gmi, '/'));
+}
+
+function locateFile(basePath: string, filenames: string[]) {
+  for (const i of filenames) {
+    const p = path.resolve(basePath, i);
+    if (fs.existsSync(p)) return p;
+  }
+  return null;
+}
+
+// @ts-ignore
+nunjucks.runtime.memberLookup = function memberLookup(obj, val) {
+  if ((obj || {})._original) obj = obj._original;
+  if (obj === undefined || obj === null) return undefined;
+  if (typeof obj[val] === 'function') {
+    const fn = function (...args) {
+      return obj[val].call(obj, ...args);
+    };
+    fn._original = obj[val];
+    return fn;
+  }
+  return obj[val];
+};
+
 class Nunjucks extends nunjucks.Environment {
-  constructor() {
+  constructor(Loader: any) {
     super(new Loader(), { autoescape: true, trimBlocks: true });
     this.addFilter('await', async (promise, callback) => {
       try {
@@ -117,64 +116,109 @@ class Nunjucks extends nunjucks.Environment {
       console.log(self);
       return self;
     });
-  }
+
-}
+    // eslint-disable-next-line no-eval
-// @ts-ignore
+    this.addGlobal('eval', eval);
-nunjucks.runtime.memberLookup = function memberLookup(obj, val) {
+    this.addGlobal('Date', Date);
-  if ((obj || {})._original) obj = obj._original;
+    this.addGlobal('Object', Object);
-  if (obj === undefined || obj === null) return undefined;
+    this.addGlobal('String', String);
-  if (typeof obj[val] === 'function') {
+    this.addGlobal('Array', Array);
-    const fn = function (...args) {
+    this.addGlobal('Math', Math);
-      return obj[val].call(obj, ...args);
+    this.addGlobal('process', process);
-    };
+    this.addGlobal('global', global);
-    fn._original = obj[val];
+    this.addGlobal('typeof', (o) => typeof o);
-    return fn;
+    this.addGlobal('instanceof', (a, b) => a instanceof b);
-  }
+    this.addGlobal('paginate', misc.paginate);
-  return obj[val];
+    this.addGlobal('size', misc.size);
-};
+    this.addGlobal('utils', { status });
-const env = new Nunjucks();
+    this.addGlobal('avatarUrl', avatar);
-// eslint-disable-next-line no-eval
+    this.addGlobal('formatSeconds', misc.formatSeconds);
-env.addGlobal('eval', eval);
+    this.addGlobal('lib', global.Hydro.lib);
-env.addGlobal('Date', Date);
+    this.addGlobal('model', global.Hydro.model);
-env.addGlobal('Object', Object);
+    this.addGlobal('ui', global.Hydro.ui);
-env.addGlobal('String', String);
+    this.addGlobal('isIE', (str) => {
-env.addGlobal('Array', Array);
-env.addGlobal('Math', Math);
-env.addGlobal('process', process);
-env.addGlobal('global', global);
-env.addGlobal('typeof', (o) => typeof o);
-env.addGlobal('instanceof', (a, b) => a instanceof b);
-env.addGlobal('paginate', misc.paginate);
-env.addGlobal('size', misc.size);
-env.addGlobal('utils', { status });
-env.addGlobal('avatarUrl', avatar);
-env.addGlobal('formatSeconds', misc.formatSeconds);
-env.addGlobal('lib', global.Hydro.lib);
-env.addGlobal('model', global.Hydro.model);
-env.addGlobal('ui', global.Hydro.ui);
-env.addGlobal('isIE', (str) => {
       if (!str) return false;
       if (['MSIE', 'rv:11.0'].some((i) => str.includes(i))) return true;
       if (str.includes('Chrome/') && +str.split('Chrome/')[1].split('.')[0] < 60) return true;
       return false;
-});
+    });
-env.addGlobal('set', (obj, key, val) => {
+    this.addGlobal('set', (obj, key, val) => {
       if (val !== undefined) obj[key] = val;
       else Object.assign(obj, key);
       return '';
-});
+    });
-env.addGlobal('findSubModule', (prefix) => Object.keys(global.Hydro.ui.template).filter((n) => n.startsWith(prefix)));
-env.addGlobal('templateExists', (name) => !!global.Hydro.ui.template[name]);
 
-const platformIconMap = { 'mac os': 'mac' };
+    const platformIconMap = { 'mac os': 'mac' };
-const supportedPlatformIcons = ['android', 'chromeos', 'ios', 'linux', 'mac', 'mobile', 'windows'];
+    const supportedPlatformIcons = ['android', 'chromeos', 'ios', 'linux', 'mac', 'mobile', 'windows'];
-env.addGlobal('platformIcon', (platform) => {
+    this.addGlobal('platformIcon', (platform) => {
       const key = platformIconMap[platform?.toLowerCase()] || platform?.toLowerCase();
       if (supportedPlatformIcons.includes(key)) return key;
       return 'unknown';
-});
+    });
+  }
+}
 
-const render = (name: string, state: any) => new Promise<string>((resolve, reject) => {
+export class TemplateService extends Service {
+  static inject = ['server'];
+
+  registry: Record<string, string> = {};
+
+  constructor(public ctx: Context) {
+    super(ctx, 'template');
+    const that = this;
+    ctx.on('handler/create', async (h) => {
+      h.user = h.context.HydroContext.user as any;
+      h.domain = h.context.HydroContext.domain as any;
+      h.translate = h.translate.bind(h);
+      h.url = h.url.bind(h);
+      h.ctx = h.ctx.extend({ domain: h.domain });
+      h.renderHTML = ((orig) => function (name: string, args: Record<string, any>) {
+        const s = name.split('.');
+        let templateName = `${s[0]}.${args.domainId}.${s[1]}`;
+        if (!that.registry[templateName]) templateName = name;
+        return orig(templateName, args);
+      })(h.renderHTML).bind(h);
+    });
+
+    class Loader extends nunjucks.Loader {
+      getSource(name) {
+        const src = that.registry[name];
+        const ref = that.registry[`${name}.source`];
+        if (!process.env.DEV) {
+          if (!src) throw new Error(`Cannot get template ${name}`);
+          return {
+            src,
+            path: name,
+            noCache: false,
+          };
+        }
+        let fullpath: string | null = null;
+        const p = path.resolve(template, name);
+        if (fs.existsSync(p)) fullpath = p;
+        if (!fullpath && ref && fs.existsSync(ref)) fullpath = ref;
+        if (!fullpath) {
+          if (src) {
+            return {
+              src,
+              path: name,
+              noCache: true,
+            };
+          }
+          throw new Error(`Cannot get template ${name}`);
+        }
+        return {
+          src: fs.readFileSync(fullpath, 'utf-8'),
+          path: fullpath,
+          noCache: true,
+        };
+      }
+    }
+
+    const env = new Nunjucks(Loader);
+    env.addGlobal('findSubModule', (prefix) => Object.keys(that.registry).filter((n) => n.startsWith(prefix)));
+    env.addGlobal('templateExists', (name) => !!that.registry[name]);
+
+    const render = (name: string, state: any) => new Promise<string>((resolve, reject) => {
       const start = Date.now();
       env.render(name, {
         page_name: name.split('.')[0],
@@ -193,12 +237,10 @@ const render = (name: string, state: any) => new Promise<string>((resolve, rejec
         const end = Date.now();
         if (end - start > 5000) console.error(`Render of ${name} took ${end - start}ms`);
         if (err) reject(err);
-    else resolve(res);
+        else resolve(res || '');
+      });
     });
-});
 
-export const inject = ['server'];
-export async function apply(ctx: Context) {
     ctx.server.registerRenderer('ui-default', {
       name: 'ui-default',
       output: 'html',
@@ -207,4 +249,31 @@ export async function apply(ctx: Context) {
       priority: 1,
       render: (name, args, context) => render(name, { ...context, ...args }),
     });
+  }
+
+  async [Service.setup]() {
+    const pending = global.addons;
+    const logger = this.ctx.logger('template');
+    for (const i of pending) {
+      const p = locateFile(i, ['template', 'templates']);
+      if (p && (await fs.stat(p)).isDirectory()) {
+        try {
+          const files = await getFiles(p);
+          for (const file of files) {
+            const l = path.resolve(p, file);
+            this.registry[file] = await fs.readFile(l, 'utf-8');
+            if (process.env.DEV) this.registry[`${file}.source`] = l;
+          }
+          logger.info('Template init: %s', i);
+        } catch (e) {
+          this.ctx.injectUI('Notification', 'Template load fail: {0}', { args: [i], type: 'warn' }, PRIV.PRIV_VIEW_SYSTEM_NOTIFICATION);
+          logger.error('Template Load Fail: %s', i);
+          logger.error(e);
+        }
+      }
+    }
+  }
+}
+
+export async function apply(ctx: Context) {
 }

packages/ui-default/index.ts

@@ -5,6 +5,7 @@ import {
 } from 'hydrooj';
 import convert from 'schemastery-jsonschema';
 import markdown from './backendlib/markdown';
+import { TemplateService } from './backendlib/template';
 
 class WikiHelpHandler extends Handler {
   noCheckPermView = true;
@@ -164,6 +165,6 @@ export function apply(ctx: Context) {
       domains: SystemModel.get('ui-default.domains') || [],
     };
   });
-  ctx.plugin(require('./backendlib/template'));
+  ctx.plugin(TemplateService);
   ctx.plugin(require('./backendlib/builder'));
 }