@midwayjs/mock 4.0.3 → 4.1.0

package/dist/creator.js

@@ -15,6 +15,7 @@ const fs_1 = require("fs");
 const yaml = require("js-yaml");
 const getRawBody = require("raw-body");
 const functional_1 = require("@midwayjs/core/functional");
+const sourceLoader_1 = require("./sourceLoader");
 const debug = (0, util_1.debuglog)('midway:debug');
 process.setMaxListeners(0);
 function formatPath(baseDir, p) {
@@ -128,18 +129,24 @@ async function create(appDir, options = {}) {
             });
             options.moduleLoadType = pkgJSON?.type === 'module' ? 'esm' : 'commonjs';
         }
+        if (!options.moduleLoader &&
+            options.moduleLoadType === 'esm' &&
+            (0, core_1.isTypeScriptEnvironment)()) {
+            options.moduleLoader = (0, sourceLoader_1.createSourceModuleLoader)();
+        }
+        const moduleLoader = options.moduleLoader ?? core_1.loadModule;
         if (options.baseDir) {
             if (!(0, path_1.isAbsolute)(options.baseDir)) {
                 options.baseDir = (0, path_1.join)(appDir, options.baseDir);
             }
-            await (0, core_1.loadModule)((0, path_1.join)(`${options.baseDir}`, getFileNameWithSuffix('interface')), {
+            await moduleLoader((0, path_1.join)(`${options.baseDir}`, getFileNameWithSuffix('interface')), {
                 safeLoad: true,
                 loadMode: options.moduleLoadType,
             });
         }
         else if (appDir) {
             options.baseDir = (0, path_1.join)(appDir, 'src');
-            await (0, core_1.loadModule)((0, path_1.join)(`${options.baseDir}`, getFileNameWithSuffix('interface')), {
+            await moduleLoader((0, path_1.join)(`${options.baseDir}`, getFileNameWithSuffix('interface')), {
                 safeLoad: true,
                 loadMode: options.moduleLoadType,
             });
@@ -292,15 +299,21 @@ async function createFunctionApp(baseDir, options = {}, customFrameworkModule) {
             enableCache: false,
         });
         options.moduleLoadType = pkgJSON?.type === 'module' ? 'esm' : 'commonjs';
+        if (!options.moduleLoader &&
+            options.moduleLoadType === 'esm' &&
+            (0, core_1.isTypeScriptEnvironment)()) {
+            options.moduleLoader = (0, sourceLoader_1.createSourceModuleLoader)();
+        }
+        const moduleLoader = options.moduleLoader ?? core_1.loadModule;
         if (options.baseDir) {
-            await (0, core_1.loadModule)((0, path_1.join)(`${options.baseDir}`, getFileNameWithSuffix('interface')), {
+            await moduleLoader((0, path_1.join)(`${options.baseDir}`, getFileNameWithSuffix('interface')), {
                 safeLoad: true,
                 loadMode: options.moduleLoadType,
             });
         }
         else if (options.appDir) {
             options.baseDir = `${options.appDir}/src`;
-            await (0, core_1.loadModule)((0, path_1.join)(`${options.baseDir}`, getFileNameWithSuffix('interface')), {
+            await moduleLoader((0, path_1.join)(`${options.baseDir}`, getFileNameWithSuffix('interface')), {
                 safeLoad: true,
                 loadMode: options.moduleLoadType,
             });

package/dist/interface.d.ts

@@ -8,6 +8,14 @@ export interface MockBootstrapOptions extends IMidwayBootstrapOptions, ILifeCycl
     entryFile?: string;
     bootstrapMode?: 'faas' | 'app';
     initializeMethodName?: string;
+    moduleLoader?: (p: string, options?: {
+        enableCache?: boolean;
+        loadMode?: 'commonjs' | 'esm';
+        safeLoad?: boolean;
+        warnOnLoadError?: boolean;
+        extraModuleRoot?: string[];
+        importQuery?: string;
+    }) => Promise<any>;
 }
 export type ComponentModule = {
     Configuration: new () => any;

package/dist/sourceLoader.d.ts

@@ -0,0 +1,3 @@
+import { ModuleLoader } from '@midwayjs/core';
+export declare function createSourceModuleLoader(baseLoader?: ModuleLoader): ModuleLoader;
+//# sourceMappingURL=sourceLoader.d.ts.map

package/dist/sourceLoader.js

@@ -0,0 +1,232 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSourceModuleLoader = createSourceModuleLoader;
+const core_1 = require("@midwayjs/core");
+const path_1 = require("path");
+const fs_1 = require("fs");
+const util_1 = require("util");
+const url_1 = require("url");
+const crypto = require("crypto");
+const debug = (0, util_1.debuglog)('midway:debug');
+let cachedTypeScriptCompiler;
+function resolveRelativeEsmSpecifierPath(importerFile, specifier) {
+    if (!specifier ||
+        (!specifier.startsWith('./') && !specifier.startsWith('../'))) {
+        return undefined;
+    }
+    const absolute = (0, path_1.resolve)((0, path_1.dirname)(importerFile), specifier);
+    const candidates = [absolute];
+    if (/\.(mjs|cjs|js)$/i.test(specifier)) {
+        candidates.push(absolute.replace(/\.(mjs|cjs|js)$/i, '.mts'), absolute.replace(/\.(mjs|cjs|js)$/i, '.cts'), absolute.replace(/\.(mjs|cjs|js)$/i, '.ts'), absolute.replace(/\.(mjs|cjs|js)$/i, '.tsx'));
+    }
+    else if (!/\.[a-z0-9]+$/i.test(specifier)) {
+        candidates.push(`${absolute}.mts`, `${absolute}.cts`, `${absolute}.ts`, `${absolute}.tsx`, `${absolute}.mjs`, `${absolute}.cjs`, `${absolute}.js`, `${absolute}.json`, (0, path_1.join)(absolute, 'index.mts'), (0, path_1.join)(absolute, 'index.cts'), (0, path_1.join)(absolute, 'index.ts'), (0, path_1.join)(absolute, 'index.tsx'), (0, path_1.join)(absolute, 'index.mjs'), (0, path_1.join)(absolute, 'index.cjs'), (0, path_1.join)(absolute, 'index.js'), (0, path_1.join)(absolute, 'index.json'));
+    }
+    for (const item of candidates) {
+        if ((0, fs_1.existsSync)(item)) {
+            return item;
+        }
+    }
+    return undefined;
+}
+function shouldUseEsmSourceFallback(originErr, filePath, rewritten, source) {
+    if (rewritten !== source) {
+        return true;
+    }
+    if (!/\.(mts|cts|ts|tsx)$/i.test(filePath)) {
+        return false;
+    }
+    return (originErr?.code === 'ERR_UNKNOWN_FILE_EXTENSION' ||
+        originErr instanceof SyntaxError ||
+        originErr?.name === 'SyntaxError');
+}
+function formatFallbackImportSpecifier(fromFile, toFile) {
+    let specifier = (0, path_1.relative)((0, path_1.dirname)(fromFile), toFile).split(path_1.sep).join('/');
+    if (!specifier.startsWith('.')) {
+        specifier = `./${specifier}`;
+    }
+    return specifier;
+}
+function loadTypeScriptCompiler(sourceFile) {
+    if (cachedTypeScriptCompiler) {
+        return cachedTypeScriptCompiler;
+    }
+    const searchPaths = [(0, path_1.dirname)(sourceFile), process.cwd(), __dirname];
+    for (const item of searchPaths) {
+        try {
+            cachedTypeScriptCompiler = require(require.resolve('typescript', {
+                paths: [item],
+            }));
+            return cachedTypeScriptCompiler;
+        }
+        catch {
+            // try next path
+        }
+    }
+}
+function createCompiledEsmFallbackGraph(entryFile) {
+    const tempDir = (0, fs_1.mkdtempSync)((0, path_1.join)((0, path_1.dirname)(entryFile), '.midway-esm-fallback-'));
+    const compiledFileMap = new Map();
+    const tsCompiler = loadTypeScriptCompiler(entryFile);
+    const compileFile = (sourceFile) => {
+        const existed = compiledFileMap.get(sourceFile);
+        if (existed) {
+            return existed;
+        }
+        const compiledFile = (0, path_1.join)(tempDir, `${crypto.createHash('sha1').update(sourceFile).digest('hex')}.mjs`);
+        compiledFileMap.set(sourceFile, compiledFile);
+        if (sourceFile.endsWith('.json')) {
+            const jsonSource = (0, fs_1.readFileSync)(sourceFile, { encoding: 'utf-8' });
+            (0, fs_1.writeFileSync)(compiledFile, `export default ${jsonSource};`, {
+                encoding: 'utf-8',
+            });
+            return compiledFile;
+        }
+        const source = (0, fs_1.readFileSync)(sourceFile, { encoding: 'utf-8' });
+        const rewriteByPattern = (pattern, input) => {
+            return input.replace(pattern, (full, head, spec, tail) => {
+                const resolved = resolveRelativeEsmSpecifierPath(sourceFile, spec);
+                if (!resolved) {
+                    return full;
+                }
+                const compiledDependency = compileFile(resolved);
+                const fallbackSpecifier = formatFallbackImportSpecifier(compiledFile, compiledDependency);
+                return `${head}${fallbackSpecifier}${tail}`;
+            });
+        };
+        let rewritten = source;
+        rewritten = rewriteByPattern(/(from\s+['"])([^'"]+)(['"])/g, rewritten);
+        rewritten = rewriteByPattern(/(import\s*\(\s*['"])([^'"]+)(['"]\s*\))/g, rewritten);
+        let output = rewritten;
+        if (/\.(mts|cts|ts|tsx)$/i.test(sourceFile)) {
+            if (!tsCompiler) {
+                throw new Error(`[mock]: can not transpile esm typescript file "${sourceFile}", please install "typescript" in current project`);
+            }
+            output = tsCompiler.transpileModule(rewritten, {
+                fileName: sourceFile,
+                compilerOptions: {
+                    module: tsCompiler.ModuleKind.ESNext,
+                    target: tsCompiler.ScriptTarget.ES2020,
+                    moduleResolution: tsCompiler.ModuleResolutionKind.NodeNext,
+                    esModuleInterop: true,
+                    allowSyntheticDefaultImports: true,
+                    resolveJsonModule: true,
+                    experimentalDecorators: true,
+                    emitDecoratorMetadata: true,
+                    useDefineForClassFields: false,
+                    jsx: tsCompiler.JsxEmit.ReactJSX,
+                },
+            }).outputText;
+        }
+        (0, fs_1.writeFileSync)(compiledFile, output, { encoding: 'utf-8' });
+        return compiledFile;
+    };
+    return {
+        entryFile: compileFile(entryFile),
+        cleanup() {
+            (0, fs_1.rmSync)(tempDir, {
+                recursive: true,
+                force: true,
+            });
+        },
+    };
+}
+function rewriteRelativeEsmSource(importerFile, source) {
+    let changed = false;
+    const rewriteByPattern = (pattern, input) => {
+        return input.replace(pattern, (full, head, spec, tail) => {
+            const resolved = resolveRelativeEsmSpecifierPath(importerFile, spec);
+            if (!resolved) {
+                return full;
+            }
+            let fallback = (0, path_1.relative)((0, path_1.dirname)(importerFile), resolved)
+                .split(path_1.sep)
+                .join('/');
+            if (!fallback.startsWith('.')) {
+                fallback = `./${fallback}`;
+            }
+            if (fallback === spec) {
+                return full;
+            }
+            changed = true;
+            return `${head}${fallback}${tail}`;
+        });
+    };
+    let output = source;
+    output = rewriteByPattern(/(from\s+['"])([^'"]+)(['"])/g, output);
+    output = rewriteByPattern(/(import\s*\(\s*['"])([^'"]+)(['"]\s*\))/g, output);
+    return changed ? output : source;
+}
+async function importWithSpecifierFallback(p, importQuery) {
+    const fileUrl = (0, url_1.pathToFileURL)(p);
+    if (importQuery) {
+        fileUrl.searchParams.set('mwImportQuery', importQuery);
+    }
+    try {
+        return await import(fileUrl.href);
+    }
+    catch (originErr) {
+        const source = (0, fs_1.readFileSync)(p, { encoding: 'utf-8' });
+        const rewritten = rewriteRelativeEsmSource(p, source);
+        if (!shouldUseEsmSourceFallback(originErr, p, rewritten, source)) {
+            throw originErr;
+        }
+        const fallbackGraph = createCompiledEsmFallbackGraph(p);
+        try {
+            const fallbackUrl = (0, url_1.pathToFileURL)(fallbackGraph.entryFile);
+            if (importQuery) {
+                fallbackUrl.searchParams.set('mwImportQuery', importQuery);
+            }
+            return await import(fallbackUrl.href);
+        }
+        finally {
+            fallbackGraph.cleanup();
+        }
+    }
+}
+function createSourceModuleLoader(baseLoader = core_1.loadModule) {
+    return async (p, options = {}) => {
+        options.enableCache = options.enableCache ?? true;
+        options.safeLoad = options.safeLoad ?? false;
+        options.loadMode = options.loadMode ?? 'commonjs';
+        if (p.startsWith(`.${path_1.sep}`) || p.startsWith(`..${path_1.sep}`)) {
+            p = (0, path_1.resolve)((0, path_1.dirname)(module.parent.filename), p);
+        }
+        debug(`[mock]: source load module ${p}, cache: ${options.enableCache}, mode: ${options.loadMode}, safeLoad: ${options.safeLoad}`);
+        try {
+            if (options.enableCache &&
+                options.loadMode === 'esm' &&
+                !p.endsWith('.json')) {
+                try {
+                    return await baseLoader(p, {
+                        ...options,
+                        safeLoad: false,
+                    });
+                }
+                catch {
+                    // Mock dev mode loads TS source files directly. This fallback stays in
+                    // mock on purpose so core.loadModule() can remain a plain loader.
+                    return await importWithSpecifierFallback(p, options.importQuery);
+                }
+            }
+            return await baseLoader(p, {
+                ...options,
+                safeLoad: false,
+            });
+        }
+        catch (err) {
+            if (!options.safeLoad) {
+                throw err;
+            }
+            if (options.warnOnLoadError &&
+                err.code !== 'MODULE_NOT_FOUND' &&
+                err.code !== 'ERR_MODULE_NOT_FOUND' &&
+                err.code !== 'ENOENT') {
+                console.warn(err);
+            }
+            debug(`[mock]: SafeLoadModule Warning\n\n${err.message}\n`);
+            return undefined;
+        }
+    };
+}
+//# sourceMappingURL=sourceLoader.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@midwayjs/mock",
-  "version": "4.0.3",
+  "version": "4.1.0",
   "description": "create your test app from midway framework",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -50,7 +50,7 @@
   },
   "license": "MIT",
   "devDependencies": {
-    "@midwayjs/core": "^4.0.3",
+    "@midwayjs/core": "^4.1.0",
     "@midwayjs/logger": "^4.0.0",
     "@types/amqplib": "0.10.8",
     "amqplib": "0.10.9",
@@ -64,12 +64,12 @@
     "@types/supertest": "2.0.16",
     "js-yaml": "4.1.1",
     "raw-body": "2.5.2",
-    "supertest": "6.3.3"
+    "supertest": "6.3.4"
   },
   "author": "Harry Chen <czy88840616@gmail.com>",
   "repository": {
     "type": "git",
     "url": "https://github.com/midwayjs/midway.git"
   },
-  "gitHead": "1eb7584f63456836b016f156a19a0f77a5256666"
+  "gitHead": "0e6259f761c64b844c4dcab49372c64902fbd7d8"
 }