@tego/devkit 1.3.14

package/lib/builder/buildable-packages/plugin-package.mjs

@@ -0,0 +1,357 @@
+// src/builder/buildable-packages/plugin-package.ts
+import { createRequire } from "node:module";
+import path from "node:path";
+import ncc from "@vercel/ncc";
+import react from "@vitejs/plugin-react";
+import chalk from "chalk";
+import fg from "fast-glob";
+import fs from "fs-extra";
+import { build as tsupBuild } from "tsup";
+import { build as viteBuild } from "vite";
+import cssInjectedByJsPlugin from "vite-plugin-css-injected-by-js";
+import { buildDeclaration } from "../build/buildDeclaration.mjs";
+import { EsbuildSupportExts, globExcludeFiles } from "../build/constant.mjs";
+import { tarPlugin } from "../build/tarPlugin.mjs";
+import { getPackageJson, getPkgLog, getUserConfig } from "../build/utils/index.mjs";
+import {
+  buildCheck,
+  checkFileSize,
+  checkRequire,
+  getExcludePackages,
+  getIncludePackages,
+  getPackagesFromFiles,
+  getSourcePackages
+} from "../build/utils/buildPluginUtils.mjs";
+import { getDepPkgPath, getDepsConfig } from "../build/utils/getDepsConfig.mjs";
+var require2 = createRequire(import.meta.url);
+var validExts = [".ts", ".tsx", ".js", ".jsx", ".mjs"];
+var serverGlobalFiles = ["src/**", "!src/client/**", ...globExcludeFiles];
+var clientGlobalFiles = ["src/**", "!src/server/**", ...globExcludeFiles];
+var sourceGlobalFiles = ["src/**/*.{ts,js,tsx,jsx,mjs}", "!src/**/__tests__"];
+var external = [
+  // tachybase
+  "@tachybase/acl",
+  "@tachybase/actions",
+  "@tachybase/auth",
+  "@tachybase/cache",
+  "@tachybase/client",
+  "@tachybase/database",
+  "@tachybase/data-source",
+  "@tachybase/evaluators",
+  "@tachybase/logger",
+  "@tachybase/resourcer",
+  "@tachybase/sdk",
+  "@tachybase/schema",
+  "@tachybase/components",
+  "@tachybase/requirejs",
+  "@tachybase/server",
+  "@tachybase/test",
+  "@tachybase/utils",
+  "@tachybase/globals",
+  "@tachybase/loader",
+  // @tachybase/auth
+  "jsonwebtoken",
+  // @tachybase/cache
+  "cache-manager",
+  // @tachybase/database
+  "sequelize",
+  "umzug",
+  "async-mutex",
+  // @tachybase/evaluators
+  "@formulajs/formulajs",
+  "mathjs",
+  // @tachybase/logger
+  "winston",
+  "winston-daily-rotate-file",
+  // koa
+  "koa",
+  "@koa/cors",
+  "multer",
+  "koa-bodyparser",
+  // react
+  "react",
+  "react-dom",
+  "react/jsx-runtime",
+  // react-router
+  "react-router",
+  "react-router-dom",
+  // antd
+  "antd",
+  "antd-style",
+  "@ant-design/icons",
+  "@ant-design/cssinjs",
+  // i18next
+  "i18next",
+  "react-i18next",
+  // dnd-kit 相关
+  "@dnd-kit/accessibility",
+  "@dnd-kit/core",
+  "@dnd-kit/modifiers",
+  "@dnd-kit/sortable",
+  "@dnd-kit/utilities",
+  // utils
+  "dayjs",
+  "mysql2",
+  "pg",
+  "pg-hstore",
+  "sqlite3",
+  "supertest",
+  "axios",
+  "@emotion/css",
+  "ahooks",
+  "lodash",
+  "china-division"
+];
+var pluginPrefix = (process.env.PLUGIN_PACKAGE_PREFIX || "@tachybase/plugin-,@tachybase/module-").split(",");
+var target_dir = "dist";
+function deleteServerFiles(cwd, log) {
+  log("delete server files");
+  const files = fg.globSync(["*"], {
+    cwd: path.join(cwd, target_dir),
+    absolute: true,
+    deep: 1,
+    onlyFiles: true
+  });
+  const dirs = fg.globSync(["*", "!client", "!node_modules"], {
+    cwd: path.join(cwd, target_dir),
+    absolute: true,
+    deep: 1,
+    onlyDirectories: true
+  });
+  [...files, ...dirs].forEach((item) => {
+    fs.removeSync(item);
+  });
+}
+function writeExternalPackageVersion(cwd, log) {
+  log("write external version");
+  const sourceFiles = fg.globSync(sourceGlobalFiles, { cwd, absolute: true }).map((item) => fs.readFileSync(item, "utf-8"));
+  const sourcePackages = getSourcePackages(sourceFiles);
+  const excludePackages = getExcludePackages(sourcePackages, external, pluginPrefix);
+  const data = excludePackages.reduce((prev, packageName) => {
+    try {
+      const depPkgPath = getDepPkgPath(packageName, cwd);
+      const depPkg = require2(depPkgPath);
+      prev[packageName] = depPkg.version;
+    } catch (error) {
+      console.error(error);
+    }
+    return prev;
+  }, {});
+  const externalVersionPath = path.join(cwd, target_dir, "externalVersion.js");
+  fs.writeFileSync(externalVersionPath, `module.exports = ${JSON.stringify(data, null, 2)};`);
+}
+async function buildServerDeps(cwd, serverFiles, log) {
+  log("build plugin server dependencies");
+  const outDir = path.join(cwd, target_dir, "node_modules");
+  const serverFileSource = serverFiles.filter((item) => validExts.includes(path.extname(item))).map((item) => fs.readFileSync(item, "utf-8"));
+  const sourcePackages = getSourcePackages(serverFileSource);
+  const includePackages = getIncludePackages(sourcePackages, external, pluginPrefix);
+  const excludePackages = getExcludePackages(sourcePackages, external, pluginPrefix);
+  let tips = [];
+  if (includePackages.length) {
+    tips.push(
+      `These packages ${chalk.yellow(includePackages.join(", "))} will be ${chalk.italic(
+        "bundled"
+      )} to dist/node_modules.`
+    );
+  }
+  if (excludePackages.length) {
+    tips.push(`These packages ${chalk.yellow(excludePackages.join(", "))} will be ${chalk.italic("exclude")}.`);
+  }
+  log(tips.join(" "));
+  if (!includePackages.length) return;
+  const deps = getDepsConfig(cwd, outDir, includePackages, external);
+  for (const dep of Object.keys(deps)) {
+    const { outputDir, mainFile, pkg, nccConfig, depDir } = deps[dep];
+    const outputPackageJson = path.join(outputDir, "package.json");
+    if (fs.existsSync(outputPackageJson)) {
+      const outputPackage = require2(outputPackageJson);
+      if (outputPackage.version === pkg.version) {
+        continue;
+      }
+    }
+    await fs.copy(depDir, outputDir, { errorOnExist: false });
+    const deleteFiles = fg.sync(
+      [
+        "./**/*.map",
+        "./**/*.js.map",
+        "./**/*.md",
+        "./**/*.mjs",
+        "./**/*.png",
+        "./**/*.jpg",
+        "./**/*.jpeg",
+        "./**/*.gif",
+        "./**/*/.bin",
+        "./**/*/bin",
+        "./**/*/LICENSE",
+        "./**/*/tsconfig.json"
+      ],
+      { cwd: outputDir, absolute: true }
+    );
+    deleteFiles.forEach((file) => {
+      fs.unlinkSync(file);
+    });
+    await ncc(dep, nccConfig).then(
+      ({ code, assets }) => {
+        fs.writeFileSync(mainFile, code, "utf-8");
+        Object.entries(assets).forEach(([name, item]) => {
+          const fileurl = path.join(outputDir, name);
+          if (!fs.existsSync(path.dirname(fileurl))) {
+            fs.mkdirSync(path.dirname(fileurl), { recursive: true });
+          }
+          fs.writeFileSync(path.join(outputDir, name), item.source, {
+            encoding: "utf-8",
+            mode: item.permissions
+          });
+        });
+        fs.writeFileSync(
+          outputPackageJson,
+          JSON.stringify({
+            ...pkg,
+            _lastModified: (/* @__PURE__ */ new Date()).toISOString()
+          }),
+          "utf-8"
+        );
+      }
+    );
+  }
+}
+async function buildPluginServer(cwd, userConfig, sourcemap, log) {
+  log("build plugin server source");
+  const packageJson = getPackageJson(cwd);
+  const serverFiles = fg.globSync(serverGlobalFiles, { cwd, absolute: true });
+  buildCheck({ cwd, packageJson, entry: "server", files: serverFiles, log });
+  const otherExts = Array.from(
+    new Set(serverFiles.map((item) => path.extname(item)).filter((item) => !EsbuildSupportExts.includes(item)))
+  );
+  if (otherExts.length) {
+    log("%s will not be processed, only be copied to the dist directory.", chalk.yellow(otherExts.join(",")));
+  }
+  deleteServerFiles(cwd, log);
+  await tsupBuild(
+    userConfig.modifyTsupConfig({
+      entry: serverFiles,
+      splitting: false,
+      clean: false,
+      bundle: false,
+      silent: true,
+      treeshake: false,
+      target: "node16",
+      sourcemap,
+      outDir: path.join(cwd, target_dir),
+      format: "cjs",
+      skipNodeModulesBundle: true,
+      loader: {
+        ...otherExts.reduce((prev, cur) => ({ ...prev, [cur]: "copy" }), {}),
+        ".json": "copy"
+      }
+    })
+  );
+  await buildServerDeps(cwd, serverFiles, log);
+}
+async function buildPluginClient(cwd, userConfig, sourcemap, log) {
+  log("build plugin client");
+  const packageJson = getPackageJson(cwd);
+  const clientFiles = fg.globSync(clientGlobalFiles, { cwd, absolute: true });
+  const clientFileSource = clientFiles.map((item) => fs.readFileSync(item, "utf-8"));
+  const sourcePackages = getPackagesFromFiles(clientFileSource);
+  const excludePackages = getExcludePackages(sourcePackages, external, pluginPrefix);
+  checkRequire(clientFiles, log);
+  buildCheck({ cwd, packageJson, entry: "client", files: clientFiles, log });
+  const outDir = path.join(cwd, target_dir, "client");
+  const globals = excludePackages.reduce((prev, curr) => {
+    if (curr.startsWith("@tachybase")) {
+      prev[`${curr}/client`] = curr;
+    }
+    prev[curr] = curr;
+    return prev;
+  }, {});
+  const entry = fg.globSync("src/client/index.{ts,tsx,js,jsx}", { absolute: true, cwd });
+  const outputFileName = "index.js";
+  await viteBuild(
+    userConfig.modifyViteConfig({
+      mode: process.env.NODE_ENV || "production",
+      define: {
+        "process.env.NODE_ENV": JSON.stringify(process.env.NODE_ENV || "production"),
+        "process.env.__TEST__": false,
+        "process.env.__E2E__": process.env.__E2E__ ? true : false
+      },
+      logLevel: "warn",
+      build: {
+        minify: process.env.NODE_ENV === "production",
+        outDir,
+        cssCodeSplit: false,
+        emptyOutDir: true,
+        sourcemap,
+        lib: {
+          entry,
+          formats: ["umd"],
+          name: packageJson.name,
+          fileName: () => outputFileName
+        },
+        target: ["es2015", "edge88", "firefox78", "chrome87", "safari14"],
+        rollupOptions: {
+          cache: true,
+          external: [...Object.keys(globals), "react", "react/jsx-runtime"],
+          output: {
+            exports: "named",
+            globals: {
+              react: "React",
+              "react/jsx-runtime": "jsxRuntime",
+              ...globals
+            }
+          }
+        }
+      },
+      plugins: [react(), cssInjectedByJsPlugin({ styleId: packageJson.name })]
+    })
+  );
+  checkFileSize(outDir, log);
+}
+async function buildPlugin(cwd, userConfig, sourcemap, log) {
+}
+var PluginPackage = class {
+  static name = "plugin";
+  name;
+  dir;
+  context;
+  constructor(name, dir, context) {
+    this.name = name;
+    this.dir = dir;
+    this.context = context;
+  }
+  async build() {
+    const log = getPkgLog(this.name);
+    if (this.context.onlyTar) {
+      return await tarPlugin(this.dir, log);
+    }
+    const userConfig = getUserConfig(this.dir);
+    if (userConfig.beforeBuild) {
+      log("beforeBuild");
+      await userConfig.beforeBuild(log);
+    }
+    await buildPluginClient(this.dir, userConfig, this.context.sourcemap, log);
+    await buildPluginServer(this.dir, userConfig, this.context.sourcemap, log);
+    writeExternalPackageVersion(this.dir, log);
+    if (this.context.dts) {
+      await buildDeclaration(this.dir, "dist", log);
+    }
+    if (userConfig.afterBuild) {
+      log("afterBuild");
+      await userConfig.afterBuild(log);
+    }
+    if (this.context.tar) {
+      await tarPlugin(this.dir, log);
+    }
+    log("done");
+  }
+};
+export {
+  PluginPackage,
+  buildPlugin,
+  buildPluginClient,
+  buildPluginServer,
+  buildServerDeps,
+  deleteServerFiles,
+  writeExternalPackageVersion
+};

package/lib/builder/buildable-packages/skip-package.mjs

@@ -0,0 +1,20 @@
+// src/builder/buildable-packages/skip-package.ts
+import { getPkgLog } from "../build/utils/index.mjs";
+var SkipPackage = class {
+  static name = "skip";
+  name;
+  dir;
+  context;
+  constructor(name, dir, context) {
+    this.name = name;
+    this.dir = dir;
+    this.context = context;
+  }
+  async build() {
+    const log = getPkgLog(this.name);
+    log("skip ", this.name);
+  }
+};
+export {
+  SkipPackage
+};

package/lib/builder/get-packages.mjs

@@ -0,0 +1,63 @@
+// src/builder/get-packages.ts
+import path from "node:path";
+import Topo from "@hapi/topo";
+import { findWorkspacePackages } from "@pnpm/workspace.find-packages";
+import fg from "fast-glob";
+import fs from "fs-extra";
+import { ROOT_PATH } from "./build/constant.mjs";
+import { toUnixPath } from "./build/utils/index.mjs";
+function getPackagesPath(pkgs) {
+  const allPackageJson = fg.sync(["apps/*/package.json", "packages/*/package.json"], {
+    cwd: ROOT_PATH,
+    absolute: true,
+    onlyFiles: true
+  });
+  if (pkgs.length === 0) {
+    return allPackageJson.map(toUnixPath).map((item) => path.dirname(item));
+  }
+  const allPackageInfo = allPackageJson.map((packageJsonPath) => ({
+    name: fs.readJsonSync(packageJsonPath).name,
+    path: path.dirname(toUnixPath(packageJsonPath))
+  })).reduce(
+    (acc, cur) => {
+      acc[cur.name] = cur.path;
+      return acc;
+    },
+    {}
+  );
+  const allPackagePaths = Object.values(allPackageInfo);
+  const pkgNames = pkgs.filter((item) => allPackageInfo[item]);
+  const relativePaths = pkgNames.length ? pkgs.filter((item) => !pkgNames.includes(item)) : pkgs;
+  const pkgPaths = pkgs.map((item) => allPackageInfo[item]);
+  const absPaths = allPackagePaths.filter(
+    (absPath) => relativePaths.some((relativePath) => absPath.endsWith(relativePath))
+  );
+  const dirPaths = fg.sync(pkgs, { onlyDirectories: true, absolute: true, cwd: ROOT_PATH });
+  const dirMatchPaths = allPackagePaths.filter((pkgPath) => dirPaths.some((dirPath) => pkgPath.startsWith(dirPath)));
+  return [.../* @__PURE__ */ new Set([...pkgPaths, ...absPaths, ...dirMatchPaths])];
+}
+async function getPackages(pkgs) {
+  const packagePaths = getPackagesPath(pkgs);
+  const allProjects = await findWorkspacePackages(ROOT_PATH, {
+    supportedArchitectures: {
+      os: ["current"],
+      cpu: ["current"],
+      libc: ["current"]
+    }
+  });
+  const packages = allProjects.filter((pkg) => packagePaths.includes(toUnixPath(pkg.dir)));
+  return sortPackages(packages);
+}
+function sortPackages(packages) {
+  const sorter = new Topo.Sorter();
+  for (const pkg of packages) {
+    const pkgJson = fs.readJsonSync(`${pkg.dir}/package.json`);
+    const after = Object.keys({ ...pkgJson.dependencies, ...pkgJson.devDependencies, ...pkgJson.peerDependencies });
+    sorter.add(pkg, { after, group: pkg.manifest.name });
+  }
+  return sorter.nodes;
+}
+export {
+  getPackages,
+  sortPackages
+};

package/lib/builder/index.mjs

@@ -0,0 +1,56 @@
+// src/builder/index.ts
+import { PLUGIN_PATTRN } from "./build/constant.mjs";
+import { AppWebPackage } from "./buildable-packages/app-web-package.mjs";
+import { LibPackage } from "./buildable-packages/lib-package.mjs";
+import { PluginPackage } from "./buildable-packages/plugin-package.mjs";
+import { SkipPackage } from "./buildable-packages/skip-package.mjs";
+import { getPackages } from "./get-packages.mjs";
+var TachybaseBuilder = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  #messages = [];
+  async build(pkgs) {
+    process.env.NODE_ENV = this.ctx.development ? "development" : "production";
+    let packages = await getPackages(pkgs);
+    if (packages.length === 0) {
+      console.warn("[build] No package matched");
+      return;
+    }
+    const buildable = createBuildablePackages(packages, this.ctx);
+    for (const pkg of buildable) {
+      try {
+        await pkg.build();
+      } catch (error) {
+        this.#messages.push([pkg.name, error]);
+      }
+    }
+    if (this.#messages.length > 0) {
+      this.#messages.forEach((message) => {
+        console.log(`\u{1F41B} [${message[0]}]`);
+        console.error(message[1]);
+      });
+      console.log("build failed");
+    }
+  }
+};
+function createBuildablePackages(projects, context) {
+  return projects.map((project) => {
+    const name = project.manifest.name;
+    const dir = project.dir;
+    if (PLUGIN_PATTRN.test(name)) {
+      return new PluginPackage(name, dir, context);
+    }
+    if (name === "@tego/web") {
+      return new AppWebPackage(name, dir, context);
+    }
+    if (name === "@tego/devkit") {
+      return new SkipPackage(name, dir, context);
+    }
+    return new LibPackage(name, dir, context);
+  });
+}
+export {
+  TachybaseBuilder,
+  createBuildablePackages
+};

package/lib/cli.mjs

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import chalk from "chalk";
+import { Command } from "commander";
+import semver from "semver";
+import commands from "./commands/index.mjs";
+import { genTsConfigPaths, initEnv } from "./util.mjs";
+import "./notify-updates.mjs";
+import { createRequire } from "node:module";
+var require2 = createRequire(import.meta.url);
+var cli = new Command();
+cli.version(require2("../package.json").version);
+initEnv();
+genTsConfigPaths();
+commands(cli).then(() => {
+  if (semver.satisfies(process.version, "<20")) {
+    console.error(chalk.red("[tachybase cli]: Node.js version must be >= 20"));
+    process.exit(1);
+  }
+  cli.parse(process.argv);
+});

package/lib/commands/build.mjs

@@ -0,0 +1,20 @@
+// src/commands/build.ts
+import { TachybaseBuilder } from "../builder/index.mjs";
+import { nodeCheck } from "../util.mjs";
+var build_default = (cli) => {
+  cli.command("build").allowUnknownOption().argument("[packages...]").option("-r, --retry", "retry the last failed package").option("-s, --sourcemap", "generate server sourcemap").option("--no-dts", "not generate dts").option("--tar", "tar the package").option("--only-tar", "only tar the package").option("--development", "development mode").action(async (pkgs, options) => {
+    nodeCheck();
+    const tachybaseBuilder = new TachybaseBuilder({
+      dts: options.dts,
+      sourcemap: options.sourcemap,
+      retry: options.retry,
+      tar: options.tar,
+      onlyTar: options.onlyTar,
+      development: options.development
+    });
+    await tachybaseBuilder.build(pkgs);
+  });
+};
+export {
+  build_default as default
+};

package/lib/commands/clean.mjs

@@ -0,0 +1,18 @@
+// src/commands/clean.ts
+import { isDev, run } from "../util.mjs";
+var clean_default = (cli) => {
+  cli.command("clean").option("--all").allowUnknownOption().action((opts) => {
+    if (!isDev()) {
+      return;
+    }
+    run("rimraf", ["-rf", "./storage/app-dev"]);
+    if (opts.all) {
+      run("rimraf", ["-rf", "{node_modules,.umi,tsconfig.paths.json}"]);
+    }
+    run("rimraf", ["-rf", "apps/*/{lib,esm,es,dist,node_modules}"]);
+    run("rimraf", ["-rf", "packages/*/{lib,esm,es,dist,node_modules}"]);
+  });
+};
+export {
+  clean_default as default
+};

package/lib/commands/create-nginx-conf.mjs

@@ -0,0 +1,17 @@
+// src/commands/create-nginx-conf.ts
+import { readFileSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { URL } from "node:url";
+var __dirname = new URL(".", import.meta.url).pathname;
+var create_nginx_conf_default = (cli) => {
+  cli.command("create-nginx-conf").action(async (name, options) => {
+    const file = resolve(__dirname, "../../tachybase.conf.tpl");
+    const data = readFileSync(file, "utf-8");
+    const replaced = data.replace(/\{\{cwd\}\}/g, "/app/tachybase").replace(/\{\{publicPath\}\}/g, process.env.APP_PUBLIC_PATH).replace(/\{\{apiPort\}\}/g, process.env.APP_PORT);
+    const targetFile = resolve(process.cwd(), "storage", "tachybase.conf");
+    writeFileSync(targetFile, replaced);
+  });
+};
+export {
+  create_nginx_conf_default as default
+};

package/lib/commands/create-plugin.mjs

@@ -0,0 +1,18 @@
+// src/commands/create-plugin.ts
+import { resolve } from "node:path";
+import { PluginGenerator } from "../plugin-generator.mjs";
+var create_plugin_default = (cli) => {
+  cli.command("create-plugin").argument("<name>").allowUnknownOption().action(async (name, options) => {
+    const generator = new PluginGenerator({
+      cwd: resolve(process.cwd(), name),
+      args: options,
+      context: {
+        name
+      }
+    });
+    await generator.run();
+  });
+};
+export {
+  create_plugin_default as default
+};