maishu-scripts 1.0.0

package/babel.config.js

@@ -0,0 +1,6 @@
+module.exports = {
+    presets: [
+        ['@babel/preset-env', { targets: { node: 'current' } }],
+        '@babel/preset-typescript',
+    ],
+};

package/index.ts

@@ -0,0 +1,5 @@
+export { generateCode, watchDirectory } from "./modules/compile";
+
+// let sourceDir = "src";
+// let outDir = "out";
+// generateCode(sourceDir, outDir);

package/modules/compile.test.ts

@@ -0,0 +1,46 @@
+import { copyFile, generateCode, isIgnoredFile } from "./compile";
+import * as path from "path";
+import * as fs from "fs";
+import ts from "typescript";
+
+describe("Compile Test", function () {
+
+    test("copyFile test", function () {
+
+        let srcPath = "test/src";
+        let srcExists = fs.existsSync(srcPath);
+        expect(srcExists).toBe(true);
+    })
+
+    test("generateCode test", function () {
+
+        let srcPath = "test/src";
+        let destPath = "test/out";
+        if (fs.existsSync(destPath)) {
+            fs.rmdirSync(destPath, { recursive: true });
+        }
+        generateCode(srcPath, destPath);
+    })
+
+    test("isIgnored test", function () {
+        let filePath = "D:\\startdard-process\\plm-projects\\tc-api-proxy\\src\\app.controller.spec.ts";
+        let ignored = isIgnoredFile(filePath);
+        expect(ignored).toBe(true);
+    })
+
+    test("temp", function () {
+        let sourceFile = "D:\\startdard-process\\plm-projects\\tc-api-proxy\\src\\app.controller.ts";
+        let sourceCode = fs.readFileSync(sourceFile, "utf8");
+        let r = ts.transpileModule(sourceCode, {
+            compilerOptions: {
+                module: ts.ModuleKind.CommonJS,
+                target: ts.ScriptTarget.ES2015,
+                sourceMap: true
+            }
+        })
+
+        console.log(r);
+
+    })
+
+})

package/modules/compile.ts

@@ -0,0 +1,221 @@
+import * as babel from "@babel/core";
+import * as fs from "fs";
+import watch from "node-watch";
+import * as path from "path";
+import { errors } from "./errors";
+import { ProjectCompiler } from "./project-compiler";
+
+const skipFiles = ["\\S+\\.d\\.tsx?$", "\\S+\\.test\\.tsx?$", "\\S+\\.spec\\.tsx?$"]
+const outExt = ".js";
+
+type FileAction = (filePath: string, outDir: string, projectPath?: string) => void;
+let fileActions: { [ext: string]: FileAction } = {
+    ".ts": compileFile,
+    ".tsx": compileFile,
+}
+
+/** 将 sourceDir 目录下所有文件生成到 outDir */
+export function generateCode(sourceDir: string, outDir: string, projectPath?: string) {
+
+    if (!sourceDir) throw errors.argumentNull("sourceDir");
+    if (!outDir) throw errors.argumentNull("outDir");
+
+    if (!fs.existsSync(sourceDir))
+        throw errors.pathNotExists(sourceDir);
+
+    let files = fs.readdirSync(sourceDir);
+    for (let file of files) {
+        let filePath = path.join(sourceDir, file);
+        if (!fs.statSync(filePath).isFile()) {
+            continue;
+        }
+
+        let isSkip = isIgnoredFile(filePath);//skipFiles.some(pattern => new RegExp(pattern).test(filePath));
+        if (isSkip) {
+            console.log(`Skip ${filePath}`);
+            continue;
+        }
+
+        let ext = extname(file);
+        let action = fileActions[ext];
+        if (action) {
+            action(filePath, outDir, projectPath);
+        }
+    }
+
+    let dirs = fs.readdirSync(sourceDir);
+    for (let dir of dirs) {
+        let fullPath = path.join(sourceDir, dir);
+        let outDirPath = path.join(outDir, dir);
+        if (fs.statSync(fullPath).isDirectory()) {
+            generateCode(fullPath, outDirPath, projectPath);
+        }
+    }
+}
+
+/** 监听 sourceRoot 目录下所有文件变化，并生成到 outRoot */
+export function watchDirectory(sourceRoot: string, outRoot: string, projectPath?: string) {
+    watch(sourceRoot, { recursive: true }, async (evt, name) => {
+        let action = fileActions[extname(name)];
+        let outPath = path.dirname(name).replace(sourceRoot, outRoot);
+        if (action) {
+            action(name, outPath, projectPath);
+        }
+    })
+}
+
+/** 
+ * 编译特定文件，并生成到制定目录 
+ * @param sourcePath 源文件路径
+ * @param outDir 输出目录
+ * */
+export async function compileFile(sourcePath: string, outDir: string, projectPath?: string) {
+    if (!sourcePath) throw errors.argumentNull("sourcePath");
+    if (!outDir) throw errors.argumentNull("outDir");
+    // if (!fs.existsSync(sourcePath)) throw errors.pathNotExists(sourcePath);
+    if (!fs.existsSync(sourcePath)) {
+        console.warn(`Path not exists: ${sourcePath}`);
+        return;
+    }
+
+    let sourceDir = path.dirname(sourcePath);
+    let babelOptions: babel.TransformOptions;
+    let bablePath: string;
+    //= projectPath ?
+    //  ProjectCompiler.getBabelConfig(projectPath, sourceDir) : ProjectCompiler.getDefaultBabelConfig();
+    if (projectPath) {
+        let c = ProjectCompiler.getBabelConfig(projectPath, sourceDir);
+        bablePath = c.path;
+        babelOptions = c.options;
+    }
+    else {
+        babelOptions = ProjectCompiler.getDefaultBabelConfig();
+        bablePath = '';
+    }
+
+    babelOptions.filename = sourcePath;
+    babelOptions.code = false;
+    babelOptions.ast = true;
+
+
+    // let fileResult = babel.transformFileSync(sourcePath, {
+    //     filename: sourcePath, code: false, ast: true, plugins,
+    //     presets
+    // });
+    let fileResult = babel.transformFileSync(sourcePath, babelOptions);
+    if (!fileResult)
+        throw errors.compileError(sourcePath);
+
+    let ast = fileResult.ast;
+    if (!ast)
+        throw errors.compileError(sourcePath);
+
+    new ImportPathRewrite(sourcePath, ast);
+    let r = babel.transformFromAstSync(ast, undefined, {
+        filename: sourcePath, plugins: babelOptions.plugins,
+        presets: babelOptions.presets, sourceMaps: true
+    });
+    if (!r || r.code == null)
+        throw errors.compileError(sourcePath);
+
+    let ext = extname(sourcePath);
+    let outExt = fileOutExt(sourcePath);
+    let targetPath = path.join(outDir, path.basename(sourcePath).replace(ext, outExt));//sourcePath.replace(new RegExp(ext + "$"), outExt).replace(path.dirname(sourcePath), outDir);
+    let outDirPath = path.resolve(targetPath, "..");
+
+    if (r.map) {
+        r.map.file = path.basename(targetPath);
+        let sources = r.map.sources || [];
+        let sourceDir = path.dirname(sourcePath);
+        sources.forEach((s, i) => {
+            sources[i] = path.relative(outDirPath, path.join(sourceDir, s));
+        });
+        r.map.sources = sources;
+        let mapPath = targetPath + ".map";
+        if (!fs.existsSync(outDirPath))
+            fs.mkdirSync(outDirPath, { recursive: true });
+
+        fs.writeFileSync(mapPath, JSON.stringify(r.map));
+        r.code += `\n//babel file path = ${bablePath}`;
+        r.code += "\n//# sourceMappingURL=" + path.basename(mapPath);
+    }
+
+    if (!fs.existsSync(outDirPath))
+        fs.mkdirSync(outDirPath, { recursive: true });
+
+    fs.writeFileSync(targetPath, r.code);
+
+}
+
+export function copyFile(filePath: string, outDir: string) {
+    if (!filePath) throw errors.argumentNull("filePath");
+    if (!outDir) throw errors.argumentNull("outDir");
+
+    let out = filePath.replace(path.dirname(filePath), outDir);
+    let outDirPath = path.resolve(out, "..");
+
+    fs.mkdirSync(outDirPath, { recursive: true });
+
+    fs.copyFileSync(filePath, out);
+}
+
+export function isIgnoredFile(filePath: string) {
+    if (!filePath) throw errors.argumentNull("filePath");
+
+    let isSkip = skipFiles.some(pattern => new RegExp(pattern).test(filePath));
+    return isSkip;
+}
+
+function extname(file: string) {
+    // let ext = /\.[a-zA-Z]+/.exec(file)?.[0] || '';
+    let ext = path.extname(file);
+    return ext;
+}
+
+/** 
+ * 获取源文件所对应生成文件的扩展名 
+ * @param file 源文件名
+ * */
+function fileOutExt(file: string) {
+    let ext = extname(file);
+    if (ext === ".ts")
+        return outExt;
+
+    if (ext === ".tsx")
+        return outExt;
+
+    return ext;
+}
+
+class ImportPathRewrite {
+    constructor(private filePath: string, node: babel.types.File) {
+        this.traverse(node);
+    }
+
+    private traverse(node: babel.types.Node) {
+        switch (node.type) {
+            case "Program":
+                node.body.forEach(c => this.traverse(c));
+                break;
+            case "File":
+                this.traverse(node.program);
+                break;
+            case "ImportDeclaration":
+                if (node.source.type === "StringLiteral" && node.source.value.startsWith(".")) {
+                    let ext = extname(node.source.value);
+                    if (ext != outExt) {
+                        let dir = path.dirname(this.filePath);
+                        let fullPath = path.join(dir, node.source.value);
+                        console.log(`ImportDeclaration: ${fullPath} -> ${ext}`)
+                        if (fs.existsSync(fullPath) && fs.statSync(fullPath).isDirectory()) {
+                            node.source.value = node.source.value + "/index";
+                        }
+                        node.source.value += outExt;
+                    }
+                }
+                break;
+
+        }
+    }
+
+}

package/modules/errors.ts

@@ -0,0 +1,26 @@
+import { Errors as BaseErrors } from "maishu-toolkit/out/errors";
+
+class Errors extends BaseErrors {
+    compileError(filePath: string) {
+        let error = new Error(`Compile error in file: ${filePath}`);
+        error.name = Errors.prototype.compileError.name;
+        return error;
+    }
+    pathNotExists(path: string) {
+        let error = new Error(`Path not exists: ${path}`);
+        error.name = Errors.prototype.pathNotExists.name;
+        return error;
+    }
+    notAbsolutePath(path: string) {
+        let error = new Error(`Path is not absolute: ${path}`);
+        error.name = Errors.prototype.notAbsolutePath.name;
+        return error;
+    }
+    invalidBabelConfigExtension(extension: string, configPath: string) {
+        let error = new Error(`Invalid babel config file extension: ${extension}, babel config file path: ${configPath}.`);
+        error.name = Errors.prototype.invalidBabelConfigExtension.name;
+        return error;
+    }
+}
+
+export const errors = new Errors();

package/modules/import-path-rewrite.ts

@@ -0,0 +1,44 @@
+import * as path from "path";
+import * as fs from "fs";
+
+// const outExt = ".js";
+
+export class ImportPathRewrite {
+    constructor(private filePath: string, node: babel.types.File, private outExt: string) {
+        this.traverse(node);
+    }
+
+    private traverse(node: babel.types.Node) {
+        switch (node.type) {
+            case "Program":
+                node.body.forEach(c => this.traverse(c));
+                break;
+            case "File":
+                this.traverse(node.program);
+                break;
+            case "ImportDeclaration":
+                if (node.source.type === "StringLiteral" && node.source.value.startsWith(".")) {
+                    let ext = this.extname(node.source.value);
+                    if (ext != this.outExt) {
+                        let dir = path.dirname(this.filePath);
+                        let fullPath = path.join(dir, node.source.value);
+                        console.log(`ImportDeclaration: ${fullPath} -> ${ext}`)
+                        if (fs.existsSync(fullPath) && fs.statSync(fullPath).isDirectory()) {
+                            node.source.value = node.source.value + "/index";
+                        }
+                        node.source.value += this.outExt;
+                    }
+                }
+                break;
+
+        }
+    }
+
+    private extname(file: string) {
+        // let ext = /\.[a-zA-Z]+/.exec(file)?.[0] || '';
+        let ext = path.extname(file);
+        return ext;
+    }
+
+
+}

package/modules/project-compiler.test.ts

@@ -0,0 +1,36 @@
+import path from "path";
+import fs from "fs";
+import { ProjectCompiler } from "./project-compiler";
+describe('project-compiler test', function () {
+
+    let projectPath = path.join(__dirname, "..", "test");
+    let projectCompiler = new ProjectCompiler(projectPath, "src", "out");
+
+    test("findBabelConfigPath test", function () {
+        let staticPath = path.join(projectPath, "src", "static");
+        let babelConfigPath = ProjectCompiler.findBabelConfigPath(projectPath, staticPath);
+        expect(babelConfigPath).toBe(path.join(staticPath, "babel.config.json"));
+
+        let componentsPath = path.join(staticPath, "components");
+        expect(fs.existsSync(componentsPath)).toBeTruthy();
+        babelConfigPath = ProjectCompiler.findBabelConfigPath(projectPath, componentsPath);
+        expect(babelConfigPath).toBe(path.join(staticPath, "babel.config.json"));
+
+        let designPath = path.join(staticPath, "design");
+        babelConfigPath = ProjectCompiler.findBabelConfigPath(projectPath, designPath);
+        expect(babelConfigPath).toBe(path.join(designPath, "babel.config.js"));
+    })
+
+    test("loadBabelConfig test", function () {
+
+        let staticPath = path.join(projectPath, "src", "static");
+        let designPath = path.join(staticPath, "design");
+        let babelConfigPath = ProjectCompiler.findBabelConfigPath(projectPath, designPath);
+        expect(babelConfigPath).not.toBe(null);
+        let babelConfig = ProjectCompiler.loadBabelConfig(babelConfigPath as string);
+        expect(babelConfig).not.toBe(undefined);
+        expect(babelConfig.presets).not.toBe(undefined);
+
+    })
+
+});

package/modules/project-compiler.ts

@@ -0,0 +1,266 @@
+import * as nodemon from "nodemon";
+import { errors } from "./errors";
+import * as fs from "fs";
+import * as path from "path";
+import * as babel from "@babel/core";
+import { ImportPathRewrite } from "./import-path-rewrite";
+import watch from "node-watch";
+
+const tsOutExt = ".js";
+
+type FileAction = (filePath: string, outDir: string) => void;
+
+export class ProjectCompiler {
+
+    private fileActions: { [ext: string]: FileAction };
+    private skipFiles = ["\\S+\\.d\\.tsx?$", "\\S+\\.test\\.tsx?$", "\\S+\\.spec\\.tsx?$"];
+
+    constructor(private projectPath: string, private sourceDirectoryNanme: string, private outputDirectoryName: string) {
+        if (!projectPath) throw errors.argumentNull("projectPath");
+        if (!sourceDirectoryNanme) throw errors.argumentNull("sourceDirectoryNanme");
+        if (!outputDirectoryName) throw errors.argumentNull("outputDirectoryName");
+
+        if (!path.isAbsolute(projectPath))
+            throw errors.notAbsolutePath(projectPath);
+
+        let sourcePath = path.join(projectPath, sourceDirectoryNanme);
+        if (!fs.existsSync(sourcePath))
+            throw errors.pathNotExists(sourcePath);
+
+        this.fileActions = {
+            ".ts": this.compileFile.bind(this),
+            ".tsx": this.compileFile.bind(this),
+        }
+
+    }
+
+    /** 
+      * 编译特定文件，并生成到制定目录 
+      * @param sourcePath 源文件路径
+      * @param outDir 输出目录
+      * */
+    async compileFile(filePath: string, outDir: string) {
+        this.compileTypeScriptFileByBabel(filePath, outDir);
+    }
+
+    private async compileTypeScriptFileByBabel(sourcePath: string, outDir: string) {
+        if (!sourcePath) throw errors.argumentNull("sourcePath");
+        if (!outDir) throw errors.argumentNull("outDir");
+        if (!fs.existsSync(sourcePath)) throw errors.pathNotExists(sourcePath);
+
+        let sourceDir = path.dirname(sourcePath);
+        let babelConfig = ProjectCompiler.getBabelConfig(this.projectPath, sourceDir);
+        let babelOptions = babelConfig.options;
+        let babelPath = babelConfig.path;
+        babelOptions.filename = sourcePath;
+        babelOptions.code = false;
+        babelOptions.ast = true;
+
+        let fileResult = babel.transformFileSync(sourcePath, babelOptions);
+        if (!fileResult)
+            throw errors.compileError(sourcePath);
+
+        let ast = fileResult.ast;
+        if (!ast)
+            throw errors.compileError(sourcePath);
+
+        new ImportPathRewrite(sourcePath, ast, tsOutExt);
+        let r = babel.transformFromAstSync(ast, undefined, {
+            filename: sourcePath, plugins: babelOptions.plugins,
+            presets: babelOptions.presets, sourceMaps: true
+        });
+        if (!r || r.code == null)
+            throw errors.compileError(sourcePath);
+
+        let ext = path.extname(sourcePath);
+        let outExt = this.fileOutExt(sourcePath);
+        let targetPath = path.join(outDir, path.basename(sourcePath).replace(ext, outExt));
+        let outDirPath = path.resolve(targetPath, "..");
+
+        if (r.map) {
+            r.map.file = path.basename(targetPath);
+            let sources = r.map.sources || [];
+            let sourceDir = path.dirname(sourcePath);
+            sources.forEach((s, i) => {
+                sources[i] = path.relative(outDirPath, path.join(sourceDir, s));
+            });
+            r.map.sources = sources;
+            let mapPath = targetPath + ".map";
+            if (!fs.existsSync(outDirPath))
+                fs.mkdirSync(outDirPath, { recursive: true });
+
+            fs.writeFileSync(mapPath, JSON.stringify(r.map));
+            r.code += `\n//babelPath:${babelPath}`;
+            r.code += "\n//# sourceMappingURL=" + path.basename(mapPath);
+        }
+
+        if (!fs.existsSync(outDirPath))
+            fs.mkdirSync(outDirPath, { recursive: true });
+
+        fs.writeFileSync(targetPath, r.code);
+
+    }
+
+    static loadBabelConfig(configPath: string): babel.TransformOptions {
+        if (!configPath) throw errors.argumentNull("configPath");
+        if (!fs.existsSync(configPath)) throw errors.pathNotExists(configPath);
+
+        let ext = path.extname(configPath);
+        if (ext === ".json") {
+            let content = fs.readFileSync(configPath, "utf-8");
+            return JSON.parse(content);
+        }
+
+        if (ext === ".js") {
+            let module = require(configPath);
+            let config = Object.assign({}, module.default || module);
+            return config;
+        }
+
+        throw errors.invalidBabelConfigExtension(ext, configPath);
+    }
+
+    static findBabelConfigPath(projectPath: string, directoryPath: string): string | null {
+        if (!path.isAbsolute(directoryPath)) {
+            directoryPath = path.join(projectPath, directoryPath);
+        }
+
+        console.assert(path.isAbsolute(projectPath), `projectPath ${projectPath} is not absolute`);
+        console.assert(path.isAbsolute(directoryPath), `directoryPath ${directoryPath} is not absolute`);
+        let jsonConfigPath = path.join(directoryPath, "babel.config.json");
+        let jsConfigPath = path.join(directoryPath, "babel.config.js");
+        if (fs.existsSync(jsConfigPath)) {
+            return jsConfigPath;
+        }
+        if (fs.existsSync(jsonConfigPath)) {
+            return jsonConfigPath;
+        }
+
+        if (projectPath == directoryPath)
+            return null;
+
+        let parentPath = path.resolve(directoryPath, "..");
+
+        return this.findBabelConfigPath(projectPath, parentPath);
+    }
+
+    static getBabelConfig(projectPath: string, directoryPath: string): { options: babel.TransformOptions, path: string } {
+        let configPath = this.findBabelConfigPath(projectPath, directoryPath);
+        let babelOptions: babel.TransformOptions;
+        if (configPath) {
+            babelOptions = this.loadBabelConfig(configPath);
+        }
+        else {
+
+            babelOptions = this.getDefaultBabelConfig();
+        }
+
+        babelOptions.ast = true;
+        babelOptions.code = false;
+
+        return { options: babelOptions, path: configPath || '' };
+
+    }
+
+    static getDefaultBabelConfig(): babel.TransformOptions {
+        let plugins = [
+            "babel-plugin-transform-typescript-metadata",
+            ["@babel/plugin-proposal-decorators", { legacy: true }],
+            ["@babel/plugin-transform-typescript", { isTSX: true }],
+            ["@babel/plugin-transform-react-jsx", { "pragma": "React.createElement", "pragmaFrag": "React.Fragment" }],
+        ];
+        let presets = [
+            ['@babel/preset-env', { targets: { node: 'current' } }],
+        ];
+
+        let babelOptions = { plugins, presets };
+        return babelOptions;
+    }
+
+    /** 
+     * 获取源文件所对应生成文件的扩展名 
+     * @param file 源文件名
+     * */
+    private fileOutExt(file: string) {
+        let ext = path.extname(file);
+        if (ext === ".ts")
+            return tsOutExt;
+
+        if (ext === ".tsx")
+            return tsOutExt;
+
+        return ext;
+    }
+
+    private isIgnoredFile(filePath: string) {
+        if (!filePath) throw errors.argumentNull("filePath");
+
+        let isSkip = this.skipFiles.some(pattern => new RegExp(pattern).test(filePath));
+        return isSkip;
+    }
+
+    generateCode(): void;
+    generateCode(sourceDir: string, outDir: string): void;
+    generateCode(sourceDir?: string, outDir?: string): void {
+
+        // if (!sourceDir) throw errors.argumentNull("sourceDir");
+        // if (!outDir) throw errors.argumentNull("outDir");
+        if (!sourceDir)
+            sourceDir = path.join(this.projectPath, this.sourceDirectoryNanme);
+
+        if (!outDir)
+            outDir = path.join(this.projectPath, this.outputDirectoryName);
+
+        let fileActions = this.fileActions;
+
+        if (!fs.existsSync(sourceDir))
+            throw errors.pathNotExists(sourceDir);
+
+        let files = fs.readdirSync(sourceDir);
+        for (let file of files) {
+            let filePath = path.join(sourceDir, file);
+            if (!fs.statSync(filePath).isFile()) {
+                continue;
+            }
+
+            let isSkip = this.isIgnoredFile(filePath);//skipFiles.some(pattern => new RegExp(pattern).test(filePath));
+            if (isSkip) {
+                console.log(`Skip ${filePath}`);
+                continue;
+            }
+
+            let ext = path.extname(file);
+            let action = fileActions[ext];
+            if (action) {
+                action(filePath, outDir);
+            }
+        }
+
+        let dirs = fs.readdirSync(sourceDir);
+        for (let dir of dirs) {
+            let fullPath = path.join(sourceDir, dir);
+            let outDirPath = path.join(outDir, dir);
+            if (fs.statSync(fullPath).isDirectory()) {
+                this.generateCode(fullPath, outDirPath);
+            }
+        }
+    }
+
+    watchDirectory() {//sourceRoot: string, outRoot: string
+        watch(this.sourceDirectoryNanme, { recursive: true }, async (evt, name) => {
+            let action = this.fileActions[path.extname(name)];
+            let outPath = path.dirname(name).replace(this.sourceDirectoryNanme, this.outputDirectoryName);
+            if (action) {
+                action(name, outPath);
+            }
+        })
+    }
+
+
+    run() {
+        nodemon({
+            script: `./${this.outputDirectoryName}/main.js`,
+            watch: [`./${this.outputDirectoryName}/`],
+        })
+    }
+}

package/modules/run.ts

@@ -0,0 +1,8 @@
+import * as nodemon from "nodemon";
+
+export function run() {
+    nodemon({
+        script: "./out/main.js",
+        watch: ["./out/"],
+    })
+}

package/package.json

@@ -0,0 +1,24 @@
+{
+    "name": "maishu-scripts",
+    "version": "1.0.0",
+    "description": "用于对 node 项目进行代码生成，打包，运行",
+    "dependencies": {
+        "@babel/core": "^7.24.3",
+        "@babel/plugin-proposal-decorators": "^7.24.1",
+        "@babel/plugin-transform-react-jsx": "^7.23.4",
+        "@babel/plugin-transform-typescript": "^7.24.1",
+        "@types/node": "^20.12.2",
+        "babel-plugin-transform-typescript-metadata": "^0.3.2",
+        "maishu-toolkit": "^1.12.6",
+        "node-watch": "^0.7.4",
+        "nodemon": "^3.1.0",
+        "typescript": "^5.4.5"
+    },
+    "devDependencies": {
+        "@babel/preset-env": "^7.24.3",
+        "@babel/preset-typescript": "^7.24.1",
+        "@types/babel__core": "^7.20.5",
+        "@types/jest": "^29.5.12",
+        "jest": "^29.7.0"
+    }
+}

package/start.ts

@@ -0,0 +1,8 @@
+import { generateCode, watchDirectory } from "./modules/compile";
+import { run } from "./modules/run";
+
+let sourceDir = "src";
+let outDir = "out";
+generateCode(sourceDir, outDir);
+watchDirectory(sourceDir, outDir);
+run();

package/test/package.json

@@ -0,0 +1,7 @@
+{
+    "name": "test-src",
+    "devDependencies": {
+        "@nestjs/common": "^10.3.7",
+        "express": "^4.19.2"
+    }
+}

package/test/src/app.controller.ts

@@ -0,0 +1,14 @@
+import { Controller, Get } from '@nestjs/common';
+import { AppService } from './app.service';
+
+@Controller()
+export class AppController {
+  constructor(private readonly appService: AppService) {}
+
+  @Get()
+  getHello(): string {
+    return this.appService.getHello();
+  }
+
+  
+}

package/test/src/app.module.ts

@@ -0,0 +1,17 @@
+import { MiddlewareConsumer, Module, NestModule, RequestMethod } from '@nestjs/common';
+import { AppController } from './app.controller';
+import { AppService } from './app.service';
+import { ProxyMiddleware } from './middleware/proxy';
+import { ProxyController } from './controllers/proxy';
+
+@Module({
+  imports: [],
+  controllers: [AppController],
+  providers: [AppService],
+})
+export class AppModule implements NestModule {
+  configure(consumer: MiddlewareConsumer) {
+    consumer.apply(ProxyMiddleware)
+      .forRoutes({ path: "proxy/*", method: RequestMethod.GET });
+  }
+}

package/test/src/app.service.ts

@@ -0,0 +1,8 @@
+import { Injectable } from '@nestjs/common';
+
+@Injectable()
+export class AppService {
+  getHello(): string {
+    return 'Hello World!';
+  }
+}

package/test/src/config.ts

@@ -0,0 +1,16 @@
+//const config = require("../config.js").default as Config;
+import config from "../config.mjs";
+
+export interface Config {
+    plmUrl: string,
+}
+
+// TODO: 校验配置项是否正确
+if (!config || !config.plmUrl)
+    throw new Error("plmUrl is required in config.js");
+
+
+
+export function getConfig(): Config {
+    return config;
+}

package/test/src/controllers/proxy.ts

@@ -0,0 +1,13 @@
+import { Controller, Get } from '@nestjs/common';
+
+@Controller("proxy")
+export class ProxyController {
+    constructor() { 
+
+    }
+
+    @Get("*")
+    create(): string {
+        return 'tc api proxy';
+    }
+}

package/test/src/main.ts

@@ -0,0 +1,8 @@
+import { NestFactory } from '@nestjs/core';
+import { AppModule } from './app.module';
+
+async function bootstrap() {
+  const app = await NestFactory.create(AppModule);
+  await app.listen(3000);
+}
+bootstrap();

package/test/src/middleware/proxy.ts

@@ -0,0 +1,36 @@
+import { Request, Response, NextFunction } from 'express';
+import { get, request } from 'http';
+import { getConfig } from '../config';
+
+let config = getConfig();
+export class ProxyMiddleware {
+    constructor() { }
+
+    static rootPath = '/proxy/';
+    
+    async use(req: Request, res: Response, next: NextFunction) {
+        const { url, headers, method, body } = req;
+
+        let targetUrl = url.replace(ProxyMiddleware.rootPath, '/');
+        targetUrl = config.plmUrl + targetUrl;
+        console.log('targetUrl', targetUrl);
+        
+        const options = {
+            url: targetUrl,
+            headers: headers,
+            method: method,
+            body: body
+        };
+
+        // url = url.replace(ProxyMiddleware.rootPath, '');
+
+
+        const proxyReq = request(options, (proxyRes) => {
+            res.writeHead(proxyRes.statusCode, proxyRes.headers);
+            proxyRes.pipe(res);
+        });
+
+        req.pipe(proxyReq);
+
+    }
+}

package/test/src/static/babel.config.json

@@ -0,0 +1,6 @@
+{
+    "presets": [],
+    "plugins": [
+        "@babel/plugin-transform-typescript"
+    ]
+}

package/test/src/static/design/babel.config.js

@@ -0,0 +1,6 @@
+module.exports = {
+    presets: [
+        ['@babel/preset-env', { targets: { node: 'current' } }],
+        '@babel/preset-typescript',
+    ],
+};

package/test/tsconfig.json

@@ -0,0 +1,8 @@
+{
+    "compilerOptions": {
+        "noEmit": true,
+        "target": "ESNext",
+        "module": "commonjs",
+        "experimentalDecorators": true
+    }
+}