tego 1.3.12

package/src/plugin-presets.ts

@@ -0,0 +1,319 @@
+import { Plugin, PluginManager } from '@tachybase/server';
+
+import _ from 'lodash';
+
+export class PluginPresets extends Plugin {
+  #builtInPlugins = [
+    'acl',
+    'app-info',
+    'auth',
+    'backup',
+    'cloud-component',
+    'collection',
+    'cron',
+    'data-source',
+    'error-handler',
+    'event-source',
+    'file',
+    'workflow',
+    'message',
+    'pdf',
+    'ui-schema',
+    'user',
+    'web',
+    'worker-thread',
+    'env-secrets',
+  ];
+
+  get builtInPlugins() {
+    return this.#builtInPlugins;
+  }
+
+  #localPlugins = [
+    // [name, version, enabled]
+    ['action-bulk-edit', '0.22.7', true],
+    ['action-bulk-update', '0.22.7', true],
+    ['action-custom-request', '0.22.7', true],
+    ['action-duplicate', '0.22.7', true],
+    ['action-export', '0.22.7', true],
+    ['action-import', '0.22.7', true],
+    ['action-print', '0.22.7', true],
+    ['block-calendar', '0.22.7', true],
+    ['block-charts', '0.22.7', true],
+    ['block-gantt', '0.22.7', true],
+    ['block-kanban', '0.22.7', true],
+    ['block-presentation', '0.22.7', true],
+    ['field-china-region', '0.22.7', true],
+    ['field-formula', '0.22.7', true],
+    ['field-sequence', '0.22.7', true],
+    ['field-encryption', '0.23.8', true],
+    ['log-viewer', '0.22.67', true],
+    ['otp', '0.22.67', true],
+    ['instrumentation', '1.0.18', true],
+    ['full-text-search', '0.23.24', true],
+    ['password-policy', '0.23.65', true],
+    ['auth-pages', '0.23.65', true],
+    ['manual-notification', '1.0.4', true],
+    // default disable
+    ['adapter-bullmq', '0.21.76', false],
+    ['adapter-red-node', '0.22.8', false],
+    ['adapter-remix', '0.22.9', false],
+    ['api-keys', '0.10.1', false],
+    ['audit-logs', '0.22.7', false],
+    ['auth-cas', '0.13.0', false],
+    ['auth-dingtalk', '0.21.76', false],
+    ['auth-lark', '0.22.42', false],
+    ['auth-oidc', '0.9.2', false],
+    ['auth-saml', '0.8.1', false],
+    ['auth-sms', '0.10.0', false],
+    ['auth-wechat', '0.21.89', false],
+    ['auth-wecom', '0.21.76', false],
+    ['block-comments', '0.22.6', false],
+    ['block-map', '0.8.1', false],
+    ['block-step-form', '1.0.0', false],
+    ['data-source-common', '0.22.5', false],
+    ['demos-game-runesweeper', '0.22.20', false],
+    ['devtools', '0.22.82', false],
+    ['field-markdown-vditor', '0.22.6', false],
+    ['field-snapshot', '0.8.1', false],
+    ['hera', '0.22.6', false],
+    ['i18n-editor', '0.11.1', false],
+    ['multi-app', '0.7.0', false],
+    ['multi-app-share-collection', '0.9.2', false],
+    ['online-user', '0.22.7', false],
+    ['simple-cms', '0.22.6', false],
+    ['sub-accounts', '0.22.56', false],
+    ['theme-editor', '0.11.1', false],
+    ['workflow-approval', '0.22.37', false],
+    ['ai-chat', '0.23.8', false],
+    ['department', '0.23.22', false],
+    ['workflow-analysis', '0.23.41', false],
+    ['api-logs', '0.23.49', false],
+    ['ocr-convert', '1.0.12', false],
+    ['text-copy', '1.2.11', false],
+  ];
+
+  get localPlugins() {
+    return this.#localPlugins;
+  }
+
+  splitNames(name: string) {
+    return (name || '').split(',').filter(Boolean);
+  }
+
+  getBuiltInPlugins() {
+    const { PRESETS_CORE_PLUGINS } = process.env;
+    const [addPlugins, removedPlugins] = this.parseNames(PRESETS_CORE_PLUGINS);
+    return _.uniq(this.builtInPlugins.concat(addPlugins).filter((name) => !removedPlugins.includes(name)));
+  }
+
+  parseNames(plugins: string) {
+    const addPlugins = this.splitNames(plugins).filter((name) => !name.startsWith('!') && !name.startsWith('|'));
+    const removedPlugins = this.splitNames(plugins)
+      .filter((name) => name.startsWith('!'))
+      .map((name) => name.slice(1));
+
+    const addDisabledPlugins = this.splitNames(plugins)
+      .filter((name) => name.startsWith('|'))
+      .map((name) => name.slice(1));
+
+    return [addPlugins, removedPlugins, addDisabledPlugins];
+  }
+
+  getLocalPlugins() {
+    const { PRESETS_LOCAL_PLUGINS } = process.env;
+    let plugins = [].concat(this.localPlugins);
+    const [addPlugins, removedPlugins, addDisabledPlugins] = this.parseNames(PRESETS_LOCAL_PLUGINS);
+
+    addPlugins.forEach((plugin) => {
+      const found = plugins.find((p) => p[0] === plugin);
+      if (found) {
+        found[2] = true;
+      } else {
+        plugins.push([plugin, '0.0.0', true]);
+      }
+    });
+
+    removedPlugins.forEach((plugin) => {
+      plugins = plugins.filter((p) => p[0] !== plugin);
+    });
+
+    addDisabledPlugins.forEach((plugin) => {
+      const found = plugins.find((p) => p[0] === plugin);
+      if (found) {
+        found[2] = false;
+      } else {
+        plugins.push([plugin, '0.0.0', false]);
+      }
+    });
+
+    return plugins;
+  }
+
+  async getPackageJson(name) {
+    let packageName = name;
+    try {
+      packageName = await PluginManager.getPackageName(name);
+    } catch (error) {
+      packageName = name;
+    }
+    const packageJson = await PluginManager.getPackageJson(packageName);
+    return packageJson;
+  }
+
+  async allPlugins() {
+    return (
+      await Promise.all(
+        this.getBuiltInPlugins().map(async (name) => {
+          const packageJson = await this.getPackageJson(name);
+          return {
+            name,
+            packageName: packageJson.name,
+            enabled: true,
+            builtIn: true,
+            version: packageJson.version,
+          } as any;
+        }),
+      )
+    ).concat(
+      await Promise.all(
+        this.getLocalPlugins().map(async (plugin) => {
+          const name = plugin[0];
+          const enabled = plugin[2];
+          const packageJson = await this.getPackageJson(name);
+          return { name, packageName: packageJson.name, version: packageJson.version, enabled };
+        }),
+      ),
+    );
+  }
+
+  async getPluginToBeUpgraded() {
+    const repository = this.app.db.getRepository<any>('applicationPlugins');
+    const items = (await repository.find()).map((item) => item.name);
+    const plugins = await Promise.all(
+      this.getBuiltInPlugins().map(async (name) => {
+        const packageJson = await this.getPackageJson(name);
+        return {
+          name,
+          packageName: packageJson.name,
+          enabled: true,
+          builtIn: true,
+          version: packageJson.version,
+        } as any;
+      }),
+    );
+    for (const plugin of this.getLocalPlugins()) {
+      if (plugin[1]) {
+        // 不在插件列表，并且插件最低版本小于当前应用版本，跳过不处理
+        if (!items.includes(plugin[0]) && (await this.app.version.satisfies(`>${plugin[1]}`))) {
+          continue;
+        }
+      }
+      const name = plugin[0];
+      const packageJson = await this.getPackageJson(name);
+      if (items.includes(plugin[0])) {
+        plugins.push({
+          name,
+          packageName: packageJson.name,
+          version: packageJson.version,
+        });
+      } else {
+        plugins.push({
+          name,
+          packageName: packageJson.name,
+          version: packageJson.version,
+          enabled: plugin[2],
+          builtIn: false,
+        });
+      }
+    }
+    return plugins;
+  }
+
+  async updateOrCreatePlugins() {
+    const repository = this.pm.repository;
+    const plugins = await this.getPluginToBeUpgraded();
+    try {
+      await this.db.sequelize.transaction((transaction) => {
+        return Promise.all(
+          plugins.map((values) =>
+            repository.updateOrCreate({
+              transaction,
+              values,
+              filterKeys: ['name'],
+            }),
+          ),
+        );
+      });
+    } catch (err) {
+      console.error(err);
+      throw new Error('Create or update plugin error.');
+    }
+  }
+
+  async createIfNotExists() {
+    const repository = this.pm.repository;
+    const existPlugins = await repository.find();
+    const existPluginNames = existPlugins.map((item) => item.name);
+    const plugins = (await this.allPlugins()).filter((item) => !existPluginNames.includes(item.name));
+    this.filterForbidSubAppPlugin(plugins);
+    await repository.create({ values: plugins });
+  }
+
+  async install() {
+    await this.createIfNotExists();
+    this.log.info('start install built-in plugins');
+    await this.pm.repository.init();
+    await this.pm.load();
+    await this.pm.install();
+    this.log.info('finish install built-in plugins');
+  }
+
+  async upgrade() {
+    this.log.info('update built-in plugins');
+    await this.forbidSubAppPlugin();
+    await this.updateOrCreatePlugins();
+  }
+
+  getForbidSubAppPlugin() {
+    if (this.app.name === 'main') {
+      return [];
+    }
+    const { FORBID_SUB_APP_PLUGINS } = process.env;
+    return FORBID_SUB_APP_PLUGINS ? FORBID_SUB_APP_PLUGINS.split(',') : [];
+  }
+  // 从环境变量读取禁止子应用装载的插件
+  async forbidSubAppPlugin() {
+    if (this.app.name === 'main') {
+      return;
+    }
+    const forbidPlugins = this.getForbidSubAppPlugin();
+    const repository = this.pm.repository;
+    await repository.update({
+      values: {
+        subView: false,
+        enabled: false,
+      },
+      filter: {
+        name: {
+          $in: forbidPlugins,
+        },
+      },
+    });
+  }
+
+  async filterForbidSubAppPlugin(plugins: any[]) {
+    if (this.app.name === 'main') {
+      return;
+    }
+    const forbidPlugins = this.getForbidSubAppPlugin();
+    plugins.forEach((plugin) => {
+      if (forbidPlugins.includes(plugin.name)) {
+        plugin.subView = false;
+        plugin.enabled = false;
+      }
+    });
+  }
+}
+
+export default PluginPresets;

package/src/preload.ts

@@ -0,0 +1,80 @@
+import { Module } from 'node:module';
+import TachybaseGlobal from '@tachybase/globals';
+import { defineLoader } from '@tachybase/loader';
+
+import { DEFAULT_BUILTIN_PLUGINS_PATH, DEFAULT_DEV_PLUGINS_PATH, DEFAULT_REMOTE_PLUGINS_PATH } from './constants';
+
+// improve error stack
+Error.stackTraceLimit = process.env.ERROR_STACK_TRACE_LIMIT ? +process.env.ERROR_STACK_TRACE_LIMIT : 10;
+
+// 默认 NODE_MODULES_PATH 搜索路径
+if (!process.env.NODE_MODULES_PATH) {
+  process.env.NODE_MODULES_PATH = [
+    // 开发插件
+    DEFAULT_DEV_PLUGINS_PATH,
+    // 远程插件
+    DEFAULT_REMOTE_PLUGINS_PATH,
+    // 内置插件
+    DEFAULT_BUILTIN_PLUGINS_PATH,
+  ].join(',');
+}
+
+// 解析 process.env.NODE_MODULES_PATH
+const paths = process.env.NODE_MODULES_PATH.split(',');
+TachybaseGlobal.getInstance().set('PLUGIN_PATHS', paths);
+
+declare module 'node:module' {
+  // 扩展 NodeJS.Module 静态属性
+  export function _load(request: string, parent: NodeModule | null, isMain: boolean): any;
+}
+
+const originalLoad = Module._load;
+const appRoot = __dirname;
+
+// 使用加载白名单的机制
+// TODO 考虑服务端校验的版本也和这个保持同步（服务端要求的版本要和这里以及引擎的 package.json 一致）
+const defaultWhitelists = [
+  '@koa/cors',
+  '@koa/multer',
+  'async-mutex',
+  'axios',
+  'cache-manager',
+  'dayjs',
+  'dotenv',
+  'i18next',
+  'jsonwebtoken',
+  'koa',
+  'koa-bodyparser',
+  'lodash',
+  'mathjs',
+  'multer',
+  'mysql2',
+  'pg',
+  'react',
+  'react-dom',
+  'sequelize',
+  'sqlite3',
+  'umzug',
+  'winston',
+  'winston-daily-rotate-file',
+];
+
+const whitelists = new Set(defaultWhitelists);
+
+// 允许环境变量设置模块
+// 额外添加的模块会被放在指定目录 NODE_MODULES_PATH 中
+if (process.env.ENGINE_MODULES) {
+  process.env.ENGINE_MODULES.split(',').forEach((item: string) => {
+    whitelists.add(item);
+  });
+}
+
+// 加载路径包含两个，一个是引擎的启动目录，另一个是指定的插件目录
+const lookingPaths = [appRoot, ...TachybaseGlobal.getInstance().get('PLUGIN_PATHS')];
+
+// 带给子进程加载路径
+TachybaseGlobal.getInstance().set('WORKER_PATHS', lookingPaths);
+TachybaseGlobal.getInstance().set('WORKER_MODULES', [...whitelists]);
+
+// 整个加载过程允许报错，保持和默认加载器一样的行为
+Module._load = defineLoader(whitelists, originalLoad, lookingPaths);

package/src/prepare.ts

@@ -0,0 +1,96 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+
+import yoctoSpinner from '@socketregistry/yocto-spinner/index.cjs';
+import execa from 'execa';
+
+import { DEFAULT_BUILTIN_PLUGINS_RELATIVE_PATH, DEFAULT_WEB_PACKAGE_NAME } from './constants';
+import { defaultModules } from './default-modules';
+import { defaultPlugins } from './default-plugins';
+import { downloadTar, initEnvFile } from './utils';
+
+export async function prepare({
+  name,
+  plugins = defaultPlugins,
+  init = false,
+}: {
+  name?: string;
+  plugins: string[];
+  init?: boolean;
+}) {
+  if (init) {
+    if (fs.existsSync(name)) {
+      console.log(`project folder ${name} already exists, exit now.`);
+      return;
+    }
+    fs.mkdirSync(name);
+    initEnvFile(name);
+  } else {
+    name = process.cwd();
+  }
+
+  let npmExist = true;
+  // 判断 npm 是否存在
+  try {
+    await execa('npm', ['--version']);
+  } catch {
+    npmExist = false;
+  }
+
+  const prefix = path.join(name, DEFAULT_BUILTIN_PLUGINS_RELATIVE_PATH);
+  // 安装前端代码
+  console.log('🚀 ~ start download ~ front end files');
+  const spinner = yoctoSpinner({ text: `Loading ${DEFAULT_WEB_PACKAGE_NAME}` }).start();
+  await downloadTar(DEFAULT_WEB_PACKAGE_NAME, `${prefix}/${DEFAULT_WEB_PACKAGE_NAME}`);
+  spinner.success();
+  console.log();
+
+  console.log('🚀 ~ start download ~ required modules');
+  // 安装必须得模块
+  const moduleNames = defaultModules.map((moduleName) => `@tachybase/module-${moduleName}`);
+  let index = 1;
+  for (const moduleName of moduleNames) {
+    const spinner = yoctoSpinner({ text: `[${index++}/${moduleNames.length}] Loading ${moduleName}` }).start();
+    await downloadTar(moduleName, `${prefix}/${moduleName}`);
+    if (npmExist) {
+      await npmInstall(`${prefix}/${moduleName}`, spinner);
+    }
+    spinner.success();
+  }
+  console.log();
+
+  console.log('🚀 ~ start download ~ plugins');
+  // 安装可选的模块，由参数指定
+  index = 1;
+  const pluginNames = plugins.map((pluginName: string) => `@tachybase/plugin-${pluginName}`);
+  for (const pluginName of pluginNames) {
+    const spinner = yoctoSpinner({ text: `[${index++}/${pluginNames.length}] Loading ${pluginName}` }).start();
+    await downloadTar(pluginName, `${prefix}/${pluginName}`);
+    if (npmExist) {
+      await npmInstall(`${prefix}/${pluginName}`, spinner);
+    }
+    spinner.success();
+  }
+  console.log();
+}
+
+export async function npmInstall(target: string, spinner: yoctoSpinner.Spinner) {
+  // check "dependencies" field exists
+  const packageJsonPath = path.join(target, 'package.json');
+  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+  if (!packageJson.dependencies || Object.keys(packageJson.dependencies).length === 0) {
+    return;
+  }
+  const originalText = spinner.text;
+  spinner.text += ' [installing deps]';
+  await execa('npm', ['install', '--omit', 'dev', '--legacy-peer-deps'], {
+    stdio: 'inherit',
+    cwd: target,
+    env: {
+      npm_config_loglevel: 'error',
+      ...process.env,
+    },
+  });
+  spinner.text = originalText;
+}

package/src/utils.ts

@@ -0,0 +1,152 @@
+import { createHash } from 'node:crypto';
+import fs, {
+  cpSync as _cpSync,
+  existsSync as _existsSync,
+  writeFileSync as _writeFileSync,
+  createWriteStream,
+} from 'node:fs';
+import { mkdir, unlink } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+import { pipeline } from 'node:stream/promises';
+import TachybaseGlobal from '@tachybase/globals';
+
+import { config } from 'dotenv';
+import npmRegistryFetch from 'npm-registry-fetch';
+import * as tar from 'tar';
+
+import { DEFAULT_WEB_PACKAGE_NAME } from './constants';
+
+export function initEnvFile(name: string) {
+  const envPath = resolve(name, '.env');
+  if (!fs.existsSync(envPath)) {
+    fs.copyFileSync(resolve(__dirname, '../presets/.env.example'), envPath);
+    console.log('.env file created.');
+  } else {
+    console.log('.env file already exists.');
+  }
+}
+
+function parseEnv(name: string) {
+  if (name === 'DB_UNDERSCORED') {
+    if (process.env.DB_UNDERSCORED === 'true') {
+      return 'true';
+    }
+    if (process.env.DB_UNDERSCORED) {
+      return 'true';
+    }
+    return 'false';
+  }
+}
+
+export function parseEnvironment() {
+  const env = {
+    APP_ENV: 'development',
+    APP_KEY: 'test-jwt-secret',
+    APP_PORT: 3000,
+    API_BASE_PATH: '/api/',
+    DB_DIALECT: 'sqlite',
+    DB_STORAGE: 'storage/db/tachybase.sqlite',
+    DB_TIMEZONE: '+00:00',
+    DB_UNDERSCORED: parseEnv('DB_UNDERSCORED'),
+    DEFAULT_STORAGE_TYPE: 'local',
+    RUN_MODE: 'engine',
+    LOCAL_STORAGE_DEST: 'storage/uploads',
+    PLUGIN_STORAGE_PATH: resolve(process.cwd(), 'storage/plugins'),
+    MFSU_AD: 'none',
+    WS_PATH: '/ws',
+    SOCKET_PATH: 'storage/gateway.sock',
+    PM2_HOME: resolve(process.cwd(), './storage/.pm2'),
+    PLUGIN_PACKAGE_PREFIX: '@tachybase/plugin-,@tachybase/module-',
+    SERVER_TSCONFIG_PATH: './tsconfig.server.json',
+    PLAYWRIGHT_AUTH_FILE: resolve(process.cwd(), 'storage/playwright/.auth/admin.json'),
+    CACHE_DEFAULT_STORE: 'memory',
+    CACHE_MEMORY_MAX: 2000,
+    PLUGIN_STATICS_PATH: '/static/plugins/',
+    LOGGER_BASE_PATH: 'storage/logs',
+    APP_SERVER_BASE_URL: '',
+    APP_PUBLIC_PATH: '/',
+  };
+
+  config({
+    path: resolve(process.cwd(), process.env.APP_ENV_PATH || '.env'),
+  });
+
+  for (const key in env) {
+    if (!process.env[key]) {
+      process.env[key] = env[key];
+    }
+  }
+
+  if (!process.env.__env_modified__ && process.env.APP_PUBLIC_PATH) {
+    const publicPath = process.env.APP_PUBLIC_PATH.replace(/\/$/g, '');
+    const keys = ['API_BASE_PATH', 'WS_PATH', 'PLUGIN_STATICS_PATH'];
+    for (const key of keys) {
+      process.env[key] = publicPath + process.env[key];
+    }
+    process.env.__env_modified__ = '1';
+  }
+
+  if (!process.env.__env_modified__ && process.env.APP_SERVER_BASE_URL && !process.env.API_BASE_URL) {
+    process.env.API_BASE_URL = process.env.APP_SERVER_BASE_URL + process.env.API_BASE_PATH;
+    process.env.__env_modified__ = '1';
+  }
+
+  if (!process.env.SERVE_PATH) {
+    const servePath = guessServePath();
+    if (servePath) {
+      process.env.SERVE_PATH = servePath;
+    }
+  }
+}
+
+export function guessServePath() {
+  const distPath = resolve('apps/app-web/dist/index.html');
+  const clientPath = resolve('client/index.html');
+
+  if (fs.existsSync(distPath)) {
+    return resolve('apps/app-web/dist');
+  } else if (fs.existsSync(clientPath)) {
+    return resolve('client');
+  }
+
+  const pluginPaths = TachybaseGlobal.getInstance().get<string[]>('PLUGIN_PATHS');
+  for (const basePath of pluginPaths) {
+    if (fs.existsSync(resolve(basePath, DEFAULT_WEB_PACKAGE_NAME, 'dist/index.html'))) {
+      return resolve(basePath, DEFAULT_WEB_PACKAGE_NAME, 'dist');
+    }
+  }
+
+  return false;
+}
+
+async function getTarballUrl(pkgName, version = 'latest') {
+  const info = await npmRegistryFetch.json(`/${pkgName}/${version}`, {
+    query: { fullMetadata: true },
+  });
+  return info.dist.tarball;
+}
+
+export async function downloadTar(packageName: string, target: string) {
+  const url = await getTarballUrl(packageName);
+  const tarballFile = join(target, '..', `${createHash('md5').update(packageName).digest('hex')}-tarball.gz`);
+  await mkdir(dirname(tarballFile), { recursive: true });
+  const writer = createWriteStream(tarballFile);
+  const response = await fetch(url);
+  if (!response.ok || !response.body) {
+    throw new Error(`Failed to fetch tarball: ${response.statusText}`);
+  }
+
+  // 使用 pipeline 将 response.body 写入文件
+  await pipeline(response.body as any, writer);
+
+  await mkdir(target, { recursive: true });
+  await tar.x({
+    file: tarballFile,
+    gzip: true,
+    cwd: target,
+    strip: 1,
+    k: true,
+  });
+
+  await unlink(tarballFile);
+}