@tego/devkit 1.3.14

package/lib/util.mjs

@@ -0,0 +1,369 @@
+// src/util.ts
+import { createHash } from "node:crypto";
+import {
+  cpSync as _cpSync,
+  existsSync as _existsSync,
+  writeFileSync as _writeFileSync,
+  createWriteStream,
+  existsSync,
+  readFileSync,
+  rmSync,
+  symlinkSync,
+  unlinkSync,
+  writeFileSync
+} from "node:fs";
+import { mkdir, readFile, stat, unlink, writeFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { Socket } from "node:net";
+import { dirname, join, resolve, sep } from "node:path";
+import { pipeline } from "node:stream/promises";
+import chalk from "chalk";
+import { config } from "dotenv";
+import { execa } from "execa";
+import fastGlob from "fast-glob";
+import packageJson from "package-json";
+import * as tar from "tar";
+import { DEFAULT_DEV_HOST } from "./constants.mjs";
+var require2 = createRequire(import.meta.url);
+async function fsExists(path) {
+  try {
+    await stat(path);
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+function isPackageValid(pkg) {
+  try {
+    require2.resolve(pkg);
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+async function downloadTar(packageName, target) {
+  const info = await packageJson(packageName, { fullMetadata: true });
+  const url = info.dist.tarball;
+  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}`);
+  }
+  await pipeline(response.body, writer);
+  await mkdir(target, { recursive: true });
+  await tar.x({
+    file: tarballFile,
+    gzip: true,
+    cwd: target,
+    strip: 1,
+    k: true
+  });
+  await unlink(tarballFile);
+}
+function hasCorePackages() {
+  const coreDir = resolve(process.cwd(), "apps/build");
+  return existsSync(coreDir);
+}
+function hasTsNode() {
+  return isPackageValid("tsx");
+}
+function isDev() {
+  if (process.env.APP_ENV === "production") {
+    return false;
+  }
+  return hasTsNode();
+}
+var isProd = () => {
+  const { APP_SERVER_ROOT } = process.env;
+  const file = `${APP_SERVER_ROOT}/lib/index.js`;
+  if (!existsSync(resolve(process.cwd(), file))) {
+    console.log("For production environment, please build the code first.");
+    console.log();
+    console.log(chalk.yellow("$ pnpm build"));
+    console.log();
+    process.exit(1);
+  }
+  return true;
+};
+function nodeCheck() {
+  if (!hasTsNode()) {
+    console.log("Please install all dependencies");
+    console.log(chalk.yellow("$ pnpm install"));
+    process.exit(1);
+  }
+}
+function run(command, args, options) {
+  if (command === "tsx") {
+    command = "node";
+    args = ["./node_modules/tsx/dist/cli.mjs"].concat(args || []);
+  }
+  return execa(command, args, {
+    shell: true,
+    stdio: "inherit",
+    ...options,
+    env: {
+      ...process.env,
+      ...options?.env
+    }
+  });
+}
+async function isPortReachable(port, options = {}) {
+  const timeout = options.timeout ?? 1e3;
+  const host = options.host ?? "";
+  const promise = new Promise((resolve2, reject) => {
+    const socket = new Socket();
+    const onError = () => {
+      socket.destroy();
+      reject();
+    };
+    socket.setTimeout(timeout);
+    socket.once("error", onError);
+    socket.once("timeout", onError);
+    socket.connect(Number(port), host, () => {
+      socket.end();
+      resolve2();
+    });
+  });
+  try {
+    await promise;
+    return true;
+  } catch (_) {
+    return false;
+  }
+}
+async function postCheck(opts) {
+  const port = opts.port || process.env.APP_PORT || "";
+  const result = await isPortReachable(port);
+  if (result) {
+    console.error(chalk.red(`post already in use ${port}`));
+    process.exit(1);
+  }
+}
+async function runInstall() {
+  const { APP_SERVER_ROOT, SERVER_TSCONFIG_PATH } = process.env;
+  if (!SERVER_TSCONFIG_PATH) {
+    throw new Error("SERVER_TSCONFIG_PATH is empty.");
+  }
+  if (isDev()) {
+    const argv = [
+      "--tsconfig",
+      SERVER_TSCONFIG_PATH,
+      "-r",
+      "tsconfig-paths/register",
+      `${APP_SERVER_ROOT}/src/index.ts`,
+      "install",
+      "-s"
+    ];
+    await run("tsx", argv);
+  } else if (isProd()) {
+    const file = `${APP_SERVER_ROOT}/lib/index.js`;
+    const argv = [file, "install", "-s"];
+    await run("node", argv);
+  }
+}
+async function runAppCommand(command, args = []) {
+  const { APP_SERVER_ROOT, SERVER_TSCONFIG_PATH } = process.env;
+  if (!SERVER_TSCONFIG_PATH) {
+    throw new Error("SERVER_TSCONFIG_PATH is not set");
+  }
+  if (isDev()) {
+    const argv = [
+      "--tsconfig",
+      SERVER_TSCONFIG_PATH,
+      "-r",
+      "tsconfig-paths/register",
+      `${APP_SERVER_ROOT}/src/index.ts`,
+      command,
+      ...args
+    ];
+    await run("tsx", argv);
+  } else if (isProd()) {
+    const argv = [`${APP_SERVER_ROOT}/lib/index.js`, command, ...args];
+    await run("node", argv);
+  }
+}
+function promptForTs() {
+  console.log(chalk.green("WAIT: ") + "TypeScript compiling...");
+}
+async function updateJsonFile(target, fn) {
+  const content = await readFile(target, "utf-8");
+  const json = JSON.parse(content);
+  await writeFile(target, JSON.stringify(fn(json), null, 2), "utf-8");
+}
+function generateAppDir() {
+  const defaultServerRoot = join(process.cwd(), "apps/tego");
+  const defaultClientRoot = join(process.cwd(), "apps/web");
+  process.env.APP_SERVER_ROOT = process.env.APP_SERVER_ROOT || defaultServerRoot;
+  process.env.APP_CLIENT_ROOT = process.env.APP_CLIENT_ROOT || defaultClientRoot;
+}
+async function genTsConfigPaths() {
+  try {
+    unlinkSync(resolve(process.cwd(), "node_modules/.bin/tsx"));
+    symlinkSync(
+      resolve(process.cwd(), "node_modules/tsx/dist/cli.mjs"),
+      resolve(process.cwd(), "node_modules/.bin/tsx"),
+      "file"
+    );
+  } catch (error) {
+  }
+  const cwd = process.cwd();
+  const cwdLength = cwd.length;
+  const paths = {};
+  const packages = fastGlob.sync(["apps/*/package.json", "packages/*/package.json"], {
+    absolute: true,
+    onlyFiles: true
+  });
+  await Promise.all(
+    packages.map(async (packageFile) => {
+      const packageJsonName = JSON.parse(await readFile(packageFile, "utf-8")).name;
+      const packageDir = dirname(packageFile);
+      const relativePath = packageDir.slice(cwdLength + 1).split(sep).join("/");
+      paths[`${packageJsonName}/client`] = [`${relativePath}/src/client`];
+      paths[`${packageJsonName}/package.json`] = [`${relativePath}/package.json`];
+      paths[packageJsonName] = [`${relativePath}/src`];
+      if (packageJsonName === "@tachybase/test") {
+        paths[`${packageJsonName}/server`] = [`${relativePath}/src/server`];
+        paths[`${packageJsonName}/e2e`] = [`${relativePath}/src/e2e`];
+      }
+      if (packageJsonName === "@tachybase/plugin-workflow-test") {
+        paths[`${packageJsonName}/e2e`] = [`${relativePath}/src/e2e`];
+      }
+    })
+  );
+  const tsConfigJsonPath = join(cwd, "./tsconfig.paths.json");
+  const content = { compilerOptions: { paths } };
+  writeFileSync(tsConfigJsonPath, JSON.stringify(content, null, 2), "utf-8");
+  return content;
+}
+function generatePlaywrightPath(clean = false) {
+  try {
+    const playwright = resolve(process.cwd(), "storage/playwright/tests");
+    if (clean && _existsSync(playwright)) {
+      rmSync(dirname(playwright), { force: true, recursive: true });
+    }
+    if (!_existsSync(playwright)) {
+      const testPkg = require2.resolve("@tachybase/test/package.json");
+      _cpSync(resolve(dirname(testPkg), "playwright/tests"), playwright, { recursive: true });
+    }
+  } catch (error) {
+  }
+}
+function parseEnv(name) {
+  if (name === "DB_UNDERSCORED") {
+    if (process.env.DB_UNDERSCORED === "true") {
+      return "true";
+    }
+    if (process.env.DB_UNDERSCORED) {
+      return "true";
+    }
+    return "false";
+  }
+}
+function initEnv() {
+  const env = {
+    APP_ENV: "development",
+    APP_KEY: "test-jwt-secret",
+    APP_PORT: 3e3,
+    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",
+    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: 2e3,
+    PLUGIN_STATICS_PATH: "/static/plugins/",
+    LOGGER_BASE_PATH: "storage/logs",
+    APP_SERVER_BASE_URL: "",
+    APP_PUBLIC_PATH: "/"
+  };
+  if (!process.env.APP_ENV_PATH && process.argv[2] && ["test", "test:client", "test:server"].includes(process.argv[2])) {
+    if (_existsSync(resolve(process.cwd(), ".env.test"))) {
+      process.env.APP_ENV_PATH = ".env.test";
+    }
+  }
+  if (!process.env.APP_ENV_PATH && process.argv[2] === "e2e") {
+    generatePlaywrightPath();
+    if (!_existsSync(".env.e2e") && _existsSync(".env.e2e.example")) {
+      const env2 = readFileSync(".env.e2e.example");
+      _writeFileSync(".env.e2e", env2);
+    }
+    if (!_existsSync(".env.e2e")) {
+      throw new Error("Please create .env.e2e file first!");
+    }
+    process.env.APP_ENV_PATH = ".env.e2e";
+  }
+  config({
+    path: resolve(process.cwd(), process.env.APP_ENV_PATH || ".env")
+  });
+  if (process.argv[2] === "e2e" && !process.env.APP_BASE_URL) {
+    process.env.APP_BASE_URL = `http://127.0.0.1:${process.env.APP_PORT}`;
+  }
+  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__ = true;
+  }
+  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__ = true;
+  }
+}
+var getHostInUrl = async (host) => {
+  if (host === DEFAULT_DEV_HOST) {
+    return "localhost";
+  }
+  const { isIPv6 } = await import("node:net");
+  if (isIPv6(host)) {
+    return host === "::" ? "[::1]" : `[${host}]`;
+  }
+  return host;
+};
+var castArray = (arr) => {
+  if (arr === void 0) {
+    return [];
+  }
+  return Array.isArray(arr) ? arr : [arr];
+};
+export {
+  castArray,
+  downloadTar,
+  fsExists,
+  genTsConfigPaths,
+  generateAppDir,
+  generatePlaywrightPath,
+  getHostInUrl,
+  hasCorePackages,
+  hasTsNode,
+  initEnv,
+  isDev,
+  isPackageValid,
+  isPortReachable,
+  isProd,
+  nodeCheck,
+  postCheck,
+  promptForTs,
+  run,
+  runAppCommand,
+  runInstall,
+  updateJsonFile
+};

package/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "@tego/devkit",
+  "version": "1.3.14",
+  "description": "",
+  "license": "Apache-2.0",
+  "type": "module",
+  "exports": {
+    ".": "./lib/index.mjs"
+  },
+  "bin": {
+    "tachybase": "./bin/cli.js"
+  },
+  "files": [
+    "assets",
+    "bin",
+    "lib",
+    "templates",
+    "tachybase.conf.tpl"
+  ],
+  "dependencies": {
+    "@hapi/topo": "^6.0.2",
+    "@npmcli/arborist": "9.1.2",
+    "@pnpm/workspace.find-packages": "^1.1.12",
+    "@rsbuild/core": "1.4.2",
+    "@rsbuild/plugin-less": "1.2.4",
+    "@rsbuild/plugin-react": "1.3.2",
+    "@rslib/core": "0.10.4",
+    "@types/fs-extra": "^11.0.4",
+    "@umijs/utils": "3.5.43",
+    "@vercel/ncc": "0.38.3",
+    "@vitejs/plugin-react": "^4.6.0",
+    "chalk": "^5.4.1",
+    "commander": "^12.1.0",
+    "dotenv": "^16.5.0",
+    "execa": "^8.0.1",
+    "fast-glob": "^3.3.3",
+    "fs-extra": "^11.3.0",
+    "lodash": "^4.17.21",
+    "npm-packlist": "10.0.0",
+    "open": "10.1.2",
+    "p-all": "3.0.0",
+    "package-json": "10.0.1",
+    "pm2": "6.0.8",
+    "portfinder": "^1.0.37",
+    "semver": "7.7.2",
+    "serve": "^14.2.4",
+    "tar": "7.4.3",
+    "tree-kill": "^1.2.2",
+    "tsconfig-paths": "^4.2.0",
+    "tsup": "8.3.5",
+    "tsx": "4.20.3",
+    "typescript": "5.8.3",
+    "update-notifier": "7.3.1",
+    "vite": "^5.4.19",
+    "vite-plugin-css-injected-by-js": "^3.5.2",
+    "yargs-parser": "13.1.2",
+    "yocto-spinner": "1.0.0"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/lodash": "^4.17.18",
+    "@types/node": "20.17.10",
+    "@types/npm-packlist": "7.0.3",
+    "@types/npmcli__arborist": "6.3.1",
+    "@types/semver": "^7.7.0",
+    "@types/tar": "^6.1.13",
+    "@types/update-notifier": "6.0.8",
+    "cross-env": "^7.0.3",
+    "esbuild-plugin-file-path-extensions": "2.1.4",
+    "rimraf": "6.0.1",
+    "vite": "^5.4.19"
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit"
+  }
+}

package/tachybase.conf.tpl

@@ -0,0 +1,89 @@
+log_format apm '"$time_local" client=$remote_addr '
+               'method=$request_method request="$request" '
+               'request_length=$request_length '
+               'status=$status bytes_sent=$bytes_sent '
+               'body_bytes_sent=$body_bytes_sent '
+               'referer=$http_referer '
+               'user_agent="$http_user_agent" '
+               'upstream_addr=$upstream_addr '
+               'upstream_status=$upstream_status '
+               'request_time=$request_time '
+               'upstream_response_time=$upstream_response_time '
+               'upstream_connect_time=$upstream_connect_time '
+               'upstream_header_time=$upstream_header_time';
+
+server {
+    listen 80;
+    server_name _;
+    root {{cwd}}/node_modules/@tachybase/app/dist/client;
+    index index.html;
+    client_max_body_size 1000M;
+    access_log /var/log/nginx/tachybase.log apm;
+
+    gzip on;
+    gzip_types text/plain text/css application/json application/javascript text/xml application/xml application/xml+rss text/javascript;
+
+    # 不缓存 HTML 文件
+    # location ~ \.html$ {
+    #   if_modified_since off;
+    #   expires off;
+    #   etag off;
+    # }
+
+    # # 缓存 JavaScript 和 CSS 文件
+    # location ~* \.(js|css)$ {
+    #   expires 365d;
+    #   add_header Cache-Control "public";
+    # }
+
+    location {{publicPath}}storage/uploads/ {
+        alias {{cwd}}/storage/uploads/;
+        add_header Cache-Control "public";
+        access_log off;
+        autoindex off;
+    }
+
+    location {{publicPath}} {
+        alias {{cwd}}/node_modules/@tachybase/app/dist/client/;
+        try_files $uri $uri/ /index.html;
+        add_header Last-Modified $date_gmt;
+        add_header Cache-Control 'no-store, no-cache';
+        if_modified_since off;
+        expires off;
+        etag off;
+    }
+
+    location ^~ {{publicPath}}api/ {
+        proxy_pass http://127.0.0.1:{{apiPort}}{{publicPath}}api/;
+        proxy_http_version 1.1;
+        proxy_set_header Upgrade $http_upgrade;
+        proxy_set_header Connection 'upgrade';
+        proxy_set_header Host $host;
+        proxy_cache_bypass $http_upgrade;
+        proxy_connect_timeout 600;
+        proxy_send_timeout 600;
+        proxy_read_timeout 600;
+        send_timeout 600;
+    }
+
+    location ^~ {{publicPath}}static/plugins/ {
+        proxy_pass http://127.0.0.1:{{apiPort}}{{publicPath}}static/plugins/;
+        proxy_http_version 1.1;
+        proxy_set_header Upgrade $http_upgrade;
+        proxy_set_header Connection 'upgrade';
+        proxy_set_header Host $host;
+        proxy_cache_bypass $http_upgrade;
+        proxy_connect_timeout 600;
+        proxy_send_timeout 600;
+        proxy_read_timeout 600;
+        send_timeout 600;
+    }
+
+    location {{publicPath}}ws {
+      proxy_pass http://127.0.0.1:{{apiPort}}{{publicPath}}ws;
+      proxy_http_version 1.1;
+      proxy_set_header Upgrade $http_upgrade;
+      proxy_set_header Connection "Upgrade";
+      proxy_set_header Host $host;
+    }
+}

package/templates/plugin/.npmignore.tpl

@@ -0,0 +1,2 @@
+/node_modules
+/src

package/templates/plugin/README.md.tpl

@@ -0,0 +1 @@
+# {{{packageName}}}

package/templates/plugin/client.d.ts

@@ -0,0 +1,2 @@
+export * from './dist/client';
+export { default } from './dist/client';

package/templates/plugin/client.js

@@ -0,0 +1 @@
+module.exports = require('./dist/client/index.js');

package/templates/plugin/package.json.tpl

@@ -0,0 +1,11 @@
+{
+  "name": "{{{packageName}}}",
+  "version": "{{{packageVersion}}}",
+  "main": "dist/server/index.js",
+  "dependencies": {},
+  "peerDependencies": {
+    "@tachybase/client": "workspace:*",
+    "@tachybase/server": "workspace:*",
+    "@tachybase/test": "workspace:*"
+  }
+}

package/templates/plugin/server.d.ts

@@ -0,0 +1,2 @@
+export * from './dist/server';
+export { default } from './dist/server';

package/templates/plugin/server.js

@@ -0,0 +1 @@
+module.exports = require('./dist/server/index.js');

package/templates/plugin/src/client/index.ts.tpl

@@ -0,0 +1 @@
+export { default } from './plugin';

package/templates/plugin/src/client/plugin.tsx.tpl

@@ -0,0 +1,11 @@
+import { Plugin } from '@tachybase/client';
+
+class {{{pascalCaseName}}}Client extends Plugin {
+  async afterAdd() {}
+
+  async beforeLoad() {}
+
+  async load() {}
+}
+
+export default {{{pascalCaseName}}}Client;

package/templates/plugin/src/index.ts

@@ -0,0 +1,2 @@
+export * from './server';
+export { default } from './server';

package/templates/plugin/src/server/index.ts.tpl

@@ -0,0 +1 @@
+export { default } from './plugin';

package/templates/plugin/src/server/plugin.ts.tpl

@@ -0,0 +1,19 @@
+import { Plugin } from '@tachybase/server';
+
+export class {{{pascalCaseName}}}Server extends Plugin {
+  async afterAdd() {}
+
+  async beforeLoad() {}
+
+  async load() {}
+
+  async install() {}
+
+  async afterEnable() {}
+
+  async afterDisable() {}
+
+  async remove() {}
+}
+
+export default {{{pascalCaseName}}}Server;