@nocobase/plugin-client 0.10.0-alpha.5 → 0.11.0-alpha.1

package/src/server/migrations/20230620203216-admin-ui-schema-uid.ts

@@ -0,0 +1,26 @@
+import { Model } from '@nocobase/database';
+import { Migration } from '@nocobase/server';
+
+export default class extends Migration {
+  async up() {
+    const systemSettings = this.db.getRepository('systemSettings');
+    let instance: Model = await systemSettings.findOne();
+    const uiRoutes = this.db.getRepository('uiRoutes');
+    const routes = await uiRoutes.find();
+    for (const route of routes) {
+      if (route.uiSchemaUid && route?.options?.component === 'AdminLayout') {
+        const options = instance.options || {};
+        options['adminSchemaUid'] = route.uiSchemaUid;
+        instance.set('options', options);
+        instance.changed('options', true);
+        await instance.save();
+        return;
+      }
+    }
+    instance = await systemSettings.findOne();
+    if (!instance?.options?.adminSchemaUid) {
+      throw new Error('adminSchemaUid invalid');
+    }
+    this.app.log.info('systemSettings.options', instance.toJSON());
+  }
+}

package/src/server/moment-locale.ts

@@ -0,0 +1,141 @@
+const locales = {
+  af: 'af',
+  'ar-dz': 'ar-dz',
+  'ar-kw': 'ar-kw',
+  'ar-ly': 'ar-ly',
+  'ar-ma': 'ar-ma',
+  'ar-sa': 'ar-sa',
+  'ar-tn': 'ar-tn',
+  ar: 'ar',
+  az: 'az',
+  be: 'be',
+  bg: 'bg',
+  bm: 'bm',
+  'bn-bd': 'bn-bd',
+  bn: 'bn',
+  bo: 'bo',
+  br: 'br',
+  bs: 'bs',
+  ca: 'ca',
+  cs: 'cs',
+  cv: 'cv',
+  cy: 'cy',
+  da: 'da',
+  'de-at': 'de-at',
+  'de-ch': 'de-ch',
+  de: 'de',
+  dv: 'dv',
+  el: 'el',
+  'en-au': 'en-au',
+  'en-ca': 'en-ca',
+  'en-gb': 'en-gb',
+  'en-ie': 'en-ie',
+  'en-il': 'en-il',
+  'en-in': 'en-in',
+  'en-nz': 'en-nz',
+  'en-sg': 'en-sg',
+  eo: 'eo',
+  'es-do': 'es-do',
+  'es-mx': 'es-mx',
+  'es-us': 'es-us',
+  es: 'es',
+  et: 'et',
+  eu: 'eu',
+  fa: 'fa',
+  fi: 'fi',
+  fil: 'fil',
+  fo: 'fo',
+  'fr-ca': 'fr-ca',
+  'fr-ch': 'fr-ch',
+  fr: 'fr',
+  fy: 'fy',
+  ga: 'ga',
+  gd: 'gd',
+  gl: 'gl',
+  'gom-deva': 'gom-deva',
+  'gom-latn': 'gom-latn',
+  gu: 'gu',
+  he: 'he',
+  hi: 'hi',
+  hr: 'hr',
+  hu: 'hu',
+  'hy-am': 'hy-am',
+  id: 'id',
+  is: 'is',
+  'it-ch': 'it-ch',
+  it: 'it',
+  'ja-JP': 'ja',
+  jv: 'jv',
+  ka: 'ka',
+  kk: 'kk',
+  km: 'km',
+  kn: 'kn',
+  ko: 'ko',
+  ku: 'ku',
+  ky: 'ky',
+  lb: 'lb',
+  lo: 'lo',
+  lt: 'lt',
+  lv: 'lv',
+  me: 'me',
+  mi: 'mi',
+  mk: 'mk',
+  ml: 'ml',
+  mn: 'mn',
+  mr: 'mr',
+  'ms-my': 'ms-my',
+  ms: 'ms',
+  mt: 'mt',
+  my: 'my',
+  nb: 'nb',
+  ne: 'ne',
+  'nl-be': 'nl-be',
+  nl: 'nl',
+  nn: 'nn',
+  'oc-lnc': 'oc-lnc',
+  'pa-in': 'pa-in',
+  pl: 'pl',
+  'pt-br': 'pt-br',
+  pt: 'pt',
+  ro: 'ro',
+  'ru-RU': 'ru',
+  sd: 'sd',
+  se: 'se',
+  si: 'si',
+  sk: 'sk',
+  sl: 'sl',
+  sq: 'sq',
+  'sr-cyrl': 'sr-cyrl',
+  sr: 'sr',
+  ss: 'ss',
+  sv: 'sv',
+  sw: 'sw',
+  ta: 'ta',
+  te: 'te',
+  tet: 'tet',
+  tg: 'tg',
+  'th-TH': 'th',
+  tk: 'tk',
+  'tl-ph': 'tl-ph',
+  tlh: 'tlh',
+  'tr-TR': 'tr',
+  tzl: 'tzl',
+  'tzm-latn': 'tzm-latn',
+  tzm: 'tzm',
+  'ug-cn': 'ug-cn',
+  uk: 'uk',
+  ur: 'ur',
+  'uz-latn': 'uz-latn',
+  uz: 'uz',
+  vi: 'vi',
+  'x-pseudo': 'x-pseudo',
+  yo: 'yo',
+  'zh-CN': 'zh-cn',
+  'zh-hk': 'zh-hk',
+  'zh-mo': 'zh-mo',
+  'zh-TW': 'zh-tw',
+};
+
+export const getMomentLocale = (lang: string) => {
+  return locales[lang] || 'en';
+};

package/src/server/resource.ts

@@ -0,0 +1,69 @@
+import { PluginManager } from '@nocobase/server';
+
+const arr2obj = (items: any[]) => {
+  const obj = {};
+  for (const item of items) {
+    Object.assign(obj, item);
+  }
+  return obj;
+};
+
+const getResource = (packageName: string, lang: string) => {
+  const resources = [];
+  const prefixes = ['src', 'lib'];
+  const localeKeys = ['locale', 'client/locale', 'server/locale'];
+  for (const prefix of prefixes) {
+    for (const localeKey of localeKeys) {
+      try {
+        const file = `${packageName}/${prefix}/${localeKey}/${lang}`;
+        require.resolve(file);
+        const resource = require(file).default;
+        resources.push(resource);
+      } catch (error) {}
+    }
+    if (resources.length) {
+      break;
+    }
+  }
+  if (resources.length === 0 && lang.replace('-', '_') !== lang) {
+    return getResource(packageName, lang.replace('-', '_'));
+  }
+  return arr2obj(resources);
+};
+
+export const getResourceLocale = async (lang: string, db: any) => {
+  const resources = {};
+  const res = getResource('@nocobase/client', lang);
+  const defaults = getResource('@nocobase/client', 'zh-CN');
+  for (const key in defaults) {
+    if (Object.prototype.hasOwnProperty.call(defaults, key)) {
+      defaults[key] = key;
+    }
+  }
+  if (res) {
+    resources['client'] = { ...defaults, ...res };
+  } else {
+    resources['client'] = defaults;
+  }
+  const plugins = await db.getRepository('applicationPlugins').find({
+    filter: {
+      'name.$ne': 'client',
+    },
+  });
+  for (const plugin of plugins) {
+    const packageName = PluginManager.getPackageName(plugin.get('name'));
+    const res = getResource(packageName, lang);
+    const defaults = getResource(packageName, 'zh-CN');
+    for (const key in defaults) {
+      if (Object.prototype.hasOwnProperty.call(defaults, key)) {
+        defaults[key] = key;
+      }
+    }
+    if (res) {
+      resources[plugin.get('name')] = { ...defaults, ...res };
+    } else {
+      resources['client'] = defaults;
+    }
+  }
+  return resources;
+};

package/src/server/server.ts

@@ -0,0 +1,277 @@
+import { Plugin, PluginManager } from '@nocobase/server';
+import { lodash } from '@nocobase/utils';
+import fs from 'fs';
+import send from 'koa-send';
+import serve from 'koa-static';
+import { isAbsolute, resolve } from 'path';
+import { getAntdLocale } from './antd';
+import { getCronLocale } from './cron';
+import { getCronstrueLocale } from './cronstrue';
+import { getMomentLocale } from './moment-locale';
+import { getResourceLocale } from './resource';
+
+async function getReadMe(name: string, locale: string) {
+  const packageName = PluginManager.getPackageName(name);
+  const dir = resolve(process.cwd(), 'node_modules', packageName);
+  const files = [resolve(dir, `README.${locale}.md`), resolve(dir, `README.md`)];
+  const file = files.find((file) => {
+    return fs.existsSync(file);
+  });
+  return file ? (await fs.promises.readFile(file)).toString() : '';
+}
+
+async function getTabs(name: string, locale: string) {
+  const packageName = PluginManager.getPackageName(name);
+  const dir = resolve(process.cwd(), 'node_modules', packageName);
+  const file = resolve(dir, 'docs', locale, 'tabs.json');
+  if (!fs.existsSync(file)) {
+    // TODO: compatible README, remove it in all plugin has tabs.json
+    return [
+      {
+        title: 'README',
+        path: '__README__',
+      },
+    ];
+  }
+  return JSON.parse((await fs.promises.readFile(file)).toString());
+}
+
+interface TabInfoParams {
+  filterByTk: string;
+  path: string;
+  locale: string;
+}
+
+async function getTabInfo({ filterByTk, path, locale }: TabInfoParams) {
+  const packageName = PluginManager.getPackageName(filterByTk);
+  const dir = resolve(process.cwd(), 'node_modules', packageName);
+  if (path === '__README__') {
+    return await getReadMe(filterByTk, locale);
+  }
+  const files = [
+    resolve(dir, 'docs', locale, `${path}.md`),
+    // default
+    resolve(dir, 'docs', 'en-US', `${path}.md`),
+    resolve(dir, 'docs', 'zh-CN', `${path}.md`),
+  ];
+  const file = files.find((file) => {
+    return fs.existsSync(file);
+  });
+  return file ? (await fs.promises.readFile(file)).toString() : '';
+}
+
+async function getLang(ctx) {
+  const SystemSetting = ctx.db.getRepository('systemSettings');
+  const systemSetting = await SystemSetting.findOne();
+  const enabledLanguages: string[] = systemSetting.get('enabledLanguages') || [];
+  const currentUser = ctx.state.currentUser;
+  let lang = enabledLanguages?.[0] || process.env.APP_LANG || 'en-US';
+  if (enabledLanguages.includes(currentUser?.appLang)) {
+    lang = currentUser?.appLang;
+  }
+  if (ctx.request.query.locale) {
+    lang = ctx.request.query.locale;
+  }
+  return lang;
+}
+
+export class ClientPlugin extends Plugin {
+  async beforeLoad() {
+    // const cmd = this.app.findCommand('install');
+    // if (cmd) {
+    //   cmd.option('--import-demo');
+    // }
+    this.app.on('afterInstall', async (app, options) => {
+      const [opts] = options?.cliArgs || [{}];
+      if (opts?.importDemo) {
+        //
+      }
+    });
+
+    this.db.on('systemSettings.beforeCreate', async (instance, { transaction }) => {
+      const uiSchemas = this.db.getRepository<any>('uiSchemas');
+      const schema = await uiSchemas.insert(
+        {
+          type: 'void',
+          'x-component': 'Menu',
+          'x-designer': 'Menu.Designer',
+          'x-initializer': 'MenuItemInitializers',
+          'x-component-props': {
+            mode: 'mix',
+            theme: 'dark',
+            // defaultSelectedUid: 'u8',
+            onSelect: '{{ onSelect }}',
+            sideMenuRefScopeKey: 'sideMenuRef',
+          },
+          properties: {},
+        },
+        { transaction },
+      );
+      instance.set('options.adminSchemaUid', schema['x-uid']);
+    });
+  }
+
+  async load() {
+    this.db.addMigrations({
+      namespace: 'client',
+      directory: resolve(__dirname, './migrations'),
+      context: {
+        plugin: this,
+      },
+    });
+    this.app.acl.allow('app', 'getLang');
+    this.app.acl.allow('app', 'getInfo');
+    this.app.acl.allow('app', 'getPlugins');
+    this.app.acl.allow('plugins', '*', 'public');
+    this.app.acl.registerSnippet({
+      name: 'app',
+      actions: ['app:reboot', 'app:clearCache'],
+    });
+    const dialect = this.app.db.sequelize.getDialect();
+    const locales = require('./locale').default;
+    const restartMark = resolve(process.cwd(), 'storage', 'restart');
+    this.app.on('beforeStart', async () => {
+      if (fs.existsSync(restartMark)) {
+        fs.unlinkSync(restartMark);
+      }
+    });
+    this.app.resource({
+      name: 'app',
+      actions: {
+        async getInfo(ctx, next) {
+          const SystemSetting = ctx.db.getRepository('systemSettings');
+          const systemSetting = await SystemSetting.findOne();
+          const enabledLanguages: string[] = systemSetting.get('enabledLanguages') || [];
+          const currentUser = ctx.state.currentUser;
+          let lang = enabledLanguages?.[0] || process.env.APP_LANG || 'en-US';
+          if (enabledLanguages.includes(currentUser?.appLang)) {
+            lang = currentUser?.appLang;
+          }
+          ctx.body = {
+            database: {
+              dialect,
+            },
+            version: await ctx.app.version.get(),
+            lang,
+            theme: currentUser?.systemSettings?.theme || systemSetting?.options?.theme || 'default',
+          };
+          await next();
+        },
+        async getLang(ctx, next) {
+          const lang = await getLang(ctx);
+          if (lodash.isEmpty(locales[lang])) {
+            locales[lang] = {};
+          }
+          if (lodash.isEmpty(locales[lang].resources)) {
+            locales[lang].resources = await getResourceLocale(lang, ctx.db);
+          }
+          if (lodash.isEmpty(locales[lang].antd)) {
+            locales[lang].antd = getAntdLocale(lang);
+          }
+          if (lodash.isEmpty(locales[lang].cronstrue)) {
+            locales[lang].cronstrue = getCronstrueLocale(lang);
+          }
+          if (lodash.isEmpty(locales[lang].cron)) {
+            locales[lang].cron = getCronLocale(lang);
+          }
+          ctx.body = {
+            lang,
+            moment: getMomentLocale(lang),
+            ...locales[lang],
+          };
+          await next();
+        },
+        async getPlugins(ctx, next) {
+          const pm = ctx.db.getRepository('applicationPlugins');
+          const items = await pm.find({
+            filter: {
+              enabled: true,
+            },
+          });
+          ctx.body = items
+            .filter((item) => {
+              try {
+                const packageName = PluginManager.getPackageName(item.name);
+                require.resolve(`${packageName}/client`);
+                return true;
+              } catch (error) {}
+              return false;
+            })
+            .map((item) => item.name);
+          await next();
+        },
+        async clearCache(ctx, next) {
+          await ctx.cache.reset();
+          await next();
+        },
+        reboot(ctx) {
+          const RESTART_CODE = 100;
+          process.on('exit', (code) => {
+            if (code === RESTART_CODE && process.env.APP_ENV === 'production') {
+              fs.writeFileSync(restartMark, '1');
+              console.log('Restart mark created.');
+            }
+          });
+          ctx.app.on('afterStop', () => {
+            // Exit with code 100 will restart the process
+            process.exit(RESTART_CODE);
+          });
+          ctx.app.stop();
+        },
+      },
+    });
+    this.app.resource({
+      name: 'plugins',
+      actions: {
+        async getInfo(ctx, next) {
+          const lang = await getLang(ctx);
+          const { filterByTk } = ctx.action.params;
+          ctx.body = {
+            filterByTk,
+            readMe: await getReadMe(filterByTk, lang),
+          };
+          await next();
+        },
+        async getTabs(ctx, next) {
+          const lang = await getLang(ctx);
+          const { filterByTk } = ctx.action.params;
+          ctx.body = {
+            filterByTk,
+            tabs: await getTabs(filterByTk, lang),
+          };
+          await next();
+        },
+        async getTabInfo(ctx, next) {
+          const locale = await getLang(ctx);
+          const { filterByTk } = ctx.action.params;
+          ctx.body = {
+            filterByTk,
+            content: await getTabInfo({ ...(ctx.action.params as any), locale }),
+          };
+          await next();
+        },
+      },
+    });
+    let root = this.options.dist || `./packages/app/client/dist`;
+    if (!isAbsolute(root)) {
+      root = resolve(process.cwd(), root);
+    }
+    if (process.env.APP_ENV !== 'production' && root) {
+      this.app.use(
+        async (ctx, next) => {
+          if (ctx.path.startsWith(this.app.resourcer.options.prefix)) {
+            return next();
+          }
+          await serve(root)(ctx, next);
+          // console.log('koa-send', root, ctx.status);
+          if (ctx.status == 404) {
+            return send(ctx, 'index.html', { root });
+          }
+        },
+        { tag: 'clientStatic', before: 'cors' },
+      );
+    }
+  }
+}
+
+export default ClientPlugin;