简化模块加载

deprecated hydro-build

hydro/entry/common.ts

@@ -2,6 +2,7 @@
 /* eslint-disable no-eval */
 import os from 'os';
 import fs from 'fs';
+import path from 'path';
 import yaml from 'js-yaml';
 
 export const builtinLib = [
@@ -29,9 +30,22 @@ export const builtinScript = [
     'blacklist', 'setSuperadmin', 'deleteUser',
 ];
 
+function getFiles(folder, base = '') {
+    const files = [];
+    const f = fs.readdirSync(folder);
+    for (const i of f) {
+        if (!i.startsWith('.')) {
+            if (fs.statSync(path.join(folder, i)).isDirectory()) {
+                files.push(...getFiles(path.join(folder, i), path.join(base, i)));
+            } else files.push(path.join(base, i));
+        }
+    }
+    return files;
+}
+
 export async function handler(pending, fail) {
     for (const i of pending) {
-        const p = `${os.tmpdir()}/hydro/tmp/${i}/handler.js`;
+        const p = path.resolve(i, 'handler.js');
         if (fs.existsSync(p) && !fail.includes(i)) {
             try {
                 console.log(`Handler init: ${i}`);
@@ -48,10 +62,17 @@ export async function handler(pending, fail) {
 
 export async function locale(pending, fail) {
     for (const i of pending) {
-        const p = `${os.tmpdir()}/hydro/tmp/${i}/locale.json`;
-        if (fs.existsSync(p) && !fail.includes(i)) {
+        let p = path.resolve(i, 'locales');
+        if (!fs.existsSync(p)) p = path.resolve(i, 'locale');
+        if (fs.existsSync(p) && fs.statSync(p).isDirectory() && !fail.includes(i)) {
             try {
-                global.Hydro.lib.i18n(eval('require')(p));
+                const files = fs.readdirSync(p);
+                const locales = {};
+                for (const file of files) {
+                    const content = fs.readFileSync(path.resolve(p, file)).toString();
+                    locales[file.split('.')[0]] = yaml.safeLoad(content);
+                }
+                global.Hydro.lib.i18n(locales);
                 console.log(`Locale init: ${i}`);
             } catch (e) {
                 fail.push(i);
@@ -61,22 +82,19 @@ export async function locale(pending, fail) {
     }
 }
 
-export async function setting(pending, fail, modelSetting, modelSystem = null) {
+export async function setting(pending, fail, modelSetting: typeof import('../model/setting')) {
     const map = {
         system: modelSetting.SystemSetting,
         account: modelSetting.AccountSetting,
         preference: modelSetting.PreferenceSetting,
     };
     for (const i of pending) {
-        const p = `${os.tmpdir()}/hydro/tmp/${i}/setting.yaml`;
+        let p = path.resolve(i, 'setting.yaml');
+        if (!fs.existsSync(p)) p = path.resolve(i, 'settings.yaml');
         if (fs.existsSync(p) && !fail.includes(i)) {
             try {
                 const cfg: any = yaml.safeLoad(fs.readFileSync(p).toString());
                 for (const key in cfg) {
-                    if (cfg[key].default && modelSystem) {
-                        const current = await modelSystem.get(`${i}.${key}`);
-                        if (!current) await modelSystem.set(`${i}.${key}`, cfg[key].default);
-                    }
                     map[cfg[key].category || 'system'](
                         modelSetting.Setting(
                             i, `${i}.${key}`, cfg[key].range, cfg[key].default,
@@ -93,10 +111,14 @@ export async function setting(pending, fail, modelSetting, modelSystem = null) {
 
 export async function template(pending, fail) {
     for (const i of pending) {
-        const p = `${os.tmpdir()}/hydro/tmp/${i}/template.json`;
-        if (fs.existsSync(p) && !fail.includes(i)) {
+        let p = path.resolve(i, 'templates');
+        if (!fs.existsSync(p)) p = path.resolve(i, 'template');
+        if (fs.existsSync(p) && fs.statSync(p).isDirectory() && !fail.includes(i)) {
             try {
-                Object.assign(global.Hydro.template, eval('require')(p));
+                const files = getFiles(p);
+                for (const file of files) {
+                    global.Hydro.template[file] = fs.readFileSync(path.resolve(p, file)).toString();
+                }
                 console.log(`Template init: ${i}`);
             } catch (e) {
                 fail.push(i);
@@ -108,7 +130,7 @@ export async function template(pending, fail) {
 
 export async function model(pending, fail) {
     for (const i of pending) {
-        const p = `${os.tmpdir()}/hydro/tmp/${i}/model.js`;
+        const p = path.resolve(i, 'model.js');
         if (fs.existsSync(p) && !fail.includes(i)) {
             try {
                 console.log(`Model init: ${i}`);
@@ -125,7 +147,7 @@ export async function model(pending, fail) {
 
 export async function lib(pending, fail) {
     for (const i of pending) {
-        const p = `${os.tmpdir()}/hydro/tmp/${i}/lib.js`;
+        const p = path.resolve(i, 'lib.js');
         if (fs.existsSync(p) && !fail.includes(i)) {
             try {
                 console.log(`Lib init: ${i}`);
@@ -143,7 +165,7 @@ export async function lib(pending, fail) {
 
 export async function service(pending, fail) {
     for (const i of pending) {
-        const p = `${os.tmpdir()}/hydro/tmp/${i}/service.js`;
+        const p = path.resolve(i, 'service.js');
         if (fs.existsSync(p) && !fail.includes(i)) {
             try {
                 console.log(`Service init: ${i}`);
@@ -161,7 +183,7 @@ export async function service(pending, fail) {
 
 export async function script(pending, fail, active) {
     for (const i of pending) {
-        const p = `${os.tmpdir()}/hydro/tmp/${i}/script.js`;
+        const p = path.resolve(i, 'script.js');
         if (fs.existsSync(p) && !fail.includes(i)) {
             try {
                 console.time(`Script init: ${i}`);
@@ -176,3 +198,43 @@ export async function script(pending, fail, active) {
         active.push(i);
     }
 }
+
+export async function wiki(pending, fail) {
+    for (const i of pending) {
+        const p = path.resolve(i, 'wiki');
+        if (fs.existsSync(p) && fs.statSync(p).isDirectory() && !fail.includes(i)) {
+            try {
+                const r = {};
+                const categories = fs.readdirSync(p);
+                for (const category of categories) {
+                    if (!fs.statSync(p).isDirectory()) return;
+                    const pages = fs.readdirSync(path.join(p, category));
+                    const res = {};
+                    for (const page of pages) {
+                        const c = fs.readFileSync(path.join(p, category, page)).toString().split('\n');
+                        const pagename = page.split('.')[0];
+                        res[pagename] = [];
+                        let content = null;
+                        for (let j = 0; j < c.length; j++) {
+                            const line = c[j];
+                            if (line.startsWith('# ')) {
+                                if (content) res[pagename].push(content);
+                                content = {};
+                                const t = line.split('# ')[1].split('|');
+                                [content.title, content.id] = t.map((q) => q.trim());
+                                content.content = '';
+                            } else {
+                                content.content = `${content.content}${line}\n`;
+                            }
+                        }
+                    }
+                    r[category] = res;
+                }
+                console.log(`Wiki init: ${i}`);
+            } catch (e) {
+                fail.push(i);
+                console.error(`Wiki Load Fail: ${i}`);
+            }
+        }
+    }
+}