@midwayjs/core 4.0.0-beta.11 → 4.0.0-beta.13

package/dist/service/webRouterService.js

@@ -18,12 +18,14 @@ const pathToRegexp_1 = require("../util/pathToRegexp");
 const types_1 = require("../util/types");
 const interface_1 = require("../interface");
 const metadataManager_1 = require("../decorator/metadataManager");
+const loggerService_1 = require("./loggerService");
 const debug = util.debuglog('midway:debug');
 let MidwayWebRouterService = class MidwayWebRouterService {
     options;
     isReady = false;
     routes = new Map();
     routesPriority = [];
+    loggerService;
     constructor(options = {}) {
         this.options = options;
     }
@@ -33,7 +35,40 @@ let MidwayWebRouterService = class MidwayWebRouterService {
     }
     analyzeController() {
         const controllerModules = decorator_1.DecoratorManager.listModule(decorator_1.CONTROLLER_KEY);
+        const dedupedControllerModules = [];
+        const functionalControllerIndexMap = new Map();
         for (const module of controllerModules) {
+            const isFunctionalController = !!metadataManager_1.MetadataManager.getOwnMetadata(decorator_1.FUNCTIONAL_API_CONTROLLER_KEY, module);
+            if (!isFunctionalController) {
+                dedupedControllerModules.push(module);
+                continue;
+            }
+            const controllerOption = metadataManager_1.MetadataManager.getOwnMetadata(decorator_1.CONTROLLER_KEY, module);
+            const webRouterInfo = metadataManager_1.MetadataManager.getOwnMetadata(decorator_1.WEB_ROUTER_KEY, module);
+            if (!controllerOption || !webRouterInfo) {
+                dedupedControllerModules.push(module);
+                continue;
+            }
+            // Deduplicate only when controller prefix + route signatures are exactly the same.
+            // This keeps "double evaluation of same module" safe while preserving distinct APIs
+            // that happen to share class name or route method names.
+            const routeSignatures = webRouterInfo
+                .map(item => {
+                return `${(item.requestMethod || '').toLowerCase()}|${String(item.path || '/')}|${item.routerName || ''}|${item.method || ''}`;
+            })
+                .sort()
+                .join(';');
+            const controllerSignature = `${controllerOption.prefix || '/'}::${routeSignatures}`;
+            const existingIndex = functionalControllerIndexMap.get(controllerSignature);
+            if (typeof existingIndex === 'number') {
+                dedupedControllerModules[existingIndex] = module;
+            }
+            else {
+                functionalControllerIndexMap.set(controllerSignature, dedupedControllerModules.length);
+                dedupedControllerModules.push(module);
+            }
+        }
+        for (const module of dedupedControllerModules) {
             const controllerOption = metadataManager_1.MetadataManager.getOwnMetadata(decorator_1.CONTROLLER_KEY, module);
             this.addController(module, controllerOption, this.options.includeFunctionRouter);
         }
@@ -72,41 +107,37 @@ let MidwayWebRouterService = class MidwayWebRouterService {
         debug(`[core]: Found Controller ${controllerId}.`);
         const id = decorator_1.DecoratorManager.getProviderUUId(controllerClz);
         controllerOption.routerOptions = controllerOption.routerOptions || {};
-        let priority;
         // implement middleware in controller
         const middleware = controllerOption.routerOptions.middleware;
         const controllerIgnoreGlobalPrefix = !!controllerOption.routerOptions?.ignoreGlobalPrefix;
-        let prefix = (0, util_1.joinURLPath)(this.options.globalPrefix, controllerOption.prefix || '/');
-        const ignorePrefix = controllerOption.prefix || '/';
-        // if controller set ignore global prefix, all router will be ignore too.
-        if (controllerIgnoreGlobalPrefix) {
-            prefix = ignorePrefix;
-        }
+        const controllerVersion = controllerOption.routerOptions?.version;
+        const controllerVersionType = controllerVersion
+            ? controllerOption.routerOptions?.versionType || 'URI'
+            : undefined;
+        const controllerVersionPrefix = controllerVersionType === 'URI'
+            ? controllerOption.routerOptions?.versionPrefix || 'v'
+            : controllerOption.routerOptions?.versionPrefix;
+        let prefixWithGlobal = (0, util_1.joinURLPath)(this.options.globalPrefix, controllerOption.prefix || '/');
+        const rawIgnorePrefix = controllerOption.prefix || '/';
+        let ignorePrefix = rawIgnorePrefix;
         // Apply version prefix for URI versioning
-        if (controllerOption.routerOptions?.version &&
-            (!controllerOption.routerOptions?.versionType ||
-                controllerOption.routerOptions?.versionType === 'URI')) {
-            const versionPrefix = controllerOption.routerOptions?.versionPrefix || 'v';
-            const version = Array.isArray(controllerOption.routerOptions.version)
-                ? controllerOption.routerOptions.version[0]
-                : controllerOption.routerOptions.version;
-            const versionedPrefix = `/${versionPrefix}${version}`;
-            if (controllerIgnoreGlobalPrefix) {
-                prefix = (0, util_1.joinURLPath)(versionedPrefix, ignorePrefix);
-            }
-            else {
-                prefix = (0, util_1.joinURLPath)(this.options.globalPrefix, versionedPrefix, controllerOption.prefix || '/');
-            }
+        if (controllerVersion && controllerVersionType === 'URI') {
+            const version = Array.isArray(controllerVersion)
+                ? controllerVersion[0]
+                : controllerVersion;
+            const versionedPrefix = `/${controllerVersionPrefix}${version}`;
+            prefixWithGlobal = (0, util_1.joinURLPath)(this.options.globalPrefix, versionedPrefix, controllerOption.prefix || '/');
+            ignorePrefix = (0, util_1.joinURLPath)(versionedPrefix, rawIgnorePrefix);
         }
-        if (/\*/.test(prefix)) {
-            throw new error_1.MidwayCommonError(`Router prefix ${prefix} can't set string with *`);
+        if (/\*/.test(prefixWithGlobal)) {
+            throw new error_1.MidwayCommonError(`Router prefix ${prefixWithGlobal} can't set string with *`);
         }
-        // set prefix
-        if (!this.routes.has(prefix)) {
-            this.routes.set(prefix, []);
+        // set prefix with global
+        if (!this.routes.has(prefixWithGlobal)) {
+            this.routes.set(prefixWithGlobal, []);
             this.routesPriority.push({
-                prefix,
-                priority: prefix === '/' && priority === undefined ? -999 : 0,
+                prefix: prefixWithGlobal,
+                priority: prefixWithGlobal === '/' ? -999 : 0,
                 middleware,
                 routerOptions: controllerOption.routerOptions,
                 controllerId,
@@ -117,31 +148,43 @@ let MidwayWebRouterService = class MidwayWebRouterService {
             // 不同的 controller，可能会有相同的 prefix，一旦 options 不同，就要报错
             if (middleware && middleware.length > 0) {
                 const originRoute = this.routesPriority.filter(el => {
-                    return el.prefix === prefix;
+                    return el.prefix === prefixWithGlobal;
                 })[0];
-                throw new error_1.MidwayDuplicateControllerOptionsError(prefix, controllerId, originRoute.controllerId);
+                throw new error_1.MidwayDuplicateControllerOptionsError(prefixWithGlobal, controllerId, originRoute.controllerId);
             }
         }
-        // set ignorePrefix
-        if (!this.routes.has(ignorePrefix)) {
-            this.routes.set(ignorePrefix, []);
-            this.routesPriority.push({
-                prefix: ignorePrefix,
-                priority: ignorePrefix === '/' && priority === undefined ? -999 : 0,
-                middleware,
-                routerOptions: controllerOption.routerOptions,
-                controllerId,
-                routerModule: controllerClz,
-            });
-        }
         const webRouterInfo = metadataManager_1.MetadataManager.getOwnMetadata(decorator_1.WEB_ROUTER_KEY, controllerClz);
+        const hasRouteIgnoreGlobalPrefix = !!webRouterInfo &&
+            webRouterInfo.some(route => route?.ignoreGlobalPrefix === true);
+        // set ignorePrefix only when it can be matched
+        if (controllerIgnoreGlobalPrefix || hasRouteIgnoreGlobalPrefix) {
+            if (!this.routes.has(ignorePrefix)) {
+                this.routes.set(ignorePrefix, []);
+                this.routesPriority.push({
+                    prefix: ignorePrefix,
+                    priority: ignorePrefix === '/' ? -999 : 0,
+                    middleware,
+                    routerOptions: controllerOption.routerOptions,
+                    controllerId,
+                    routerModule: controllerClz,
+                });
+            }
+        }
         if (webRouterInfo && typeof webRouterInfo[Symbol.iterator] === 'function') {
             for (const webRouter of webRouterInfo) {
+                const isRouteIgnoreGlobalPrefixConfigured = webRouter.__ignoreGlobalPrefixConfigured === true;
                 const routeArgsInfo = metadataManager_1.MetadataManager.getOwnMetadata(decorator_1.WEB_ROUTER_PARAM_KEY, controllerClz, webRouter.method) || [];
                 const routerResponseData = metadataManager_1.MetadataManager.getOwnMetadata(decorator_1.WEB_RESPONSE_KEY, controllerClz, webRouter.method) || [];
                 const data = {
                     id,
-                    prefix: webRouter.ignoreGlobalPrefix ? ignorePrefix : prefix,
+                    // route-level value overrides controller default when explicitly set
+                    prefix: isRouteIgnoreGlobalPrefixConfigured
+                        ? webRouter.ignoreGlobalPrefix
+                            ? ignorePrefix
+                            : prefixWithGlobal
+                        : controllerIgnoreGlobalPrefix
+                            ? ignorePrefix
+                            : prefixWithGlobal,
                     routerName: webRouter.routerName || '',
                     url: webRouter.path,
                     requestMethod: webRouter.requestMethod,
@@ -157,12 +200,30 @@ let MidwayWebRouterService = class MidwayWebRouterService {
                     requestMetadata: routeArgsInfo,
                     responseMetadata: routerResponseData,
                 };
+                const isFunctionalController = !!metadataManager_1.MetadataManager.getOwnMetadata(decorator_1.FUNCTIONAL_API_CONTROLLER_KEY, controllerClz);
+                if (isFunctionalController) {
+                    data.source = 'functional';
+                }
+                if (isRouteIgnoreGlobalPrefixConfigured ||
+                    controllerIgnoreGlobalPrefix) {
+                    const resolvedIgnoreGlobalPrefix = isRouteIgnoreGlobalPrefixConfigured
+                        ? !!webRouter.ignoreGlobalPrefix
+                        : controllerIgnoreGlobalPrefix;
+                    if (resolvedIgnoreGlobalPrefix) {
+                        data.ignoreGlobalPrefix = true;
+                    }
+                }
+                if (controllerVersion) {
+                    data.version = controllerVersion;
+                    data.versionType = controllerVersionType;
+                    data.versionPrefix = controllerVersionPrefix;
+                }
                 if (functionMeta) {
                     // get function information
                     data.functionName = controllerId + '-' + webRouter.method;
                     data.functionTriggerName = interface_1.ServerlessTriggerType.HTTP;
                     data.functionTriggerMetadata = {
-                        path: (0, util_1.joinURLPath)(prefix, webRouter.path.toString()),
+                        path: (0, util_1.joinURLPath)(data.prefix, webRouter.path.toString()),
                         method: webRouter.requestMethod,
                     };
                     data.functionMetadata = {
@@ -315,6 +376,29 @@ let MidwayWebRouterService = class MidwayWebRouterService {
         }
         return matchedRouterInfo;
     }
+    async getRouteManifest() {
+        const routes = await this.getFlattenRouterTable();
+        const manifest = routes.map(route => ({
+            source: route.source ?? 'decorator',
+            operationId: this.getOperationId(route),
+            controllerId: route.controllerId,
+            controllerPrefix: route.prefix || '',
+            method: route.requestMethod,
+            path: route.url?.toString() || '',
+            fullPath: route.fullUrl || '',
+            routerName: route.routerName,
+            middlewareCount: (route.middleware?.length || 0) +
+                (route.controllerMiddleware?.length || 0),
+            ignoreGlobalPrefix: !!route.ignoreGlobalPrefix,
+            version: route.version,
+            versionType: route.versionType,
+            versionPrefix: route.versionPrefix,
+            summary: route.summary,
+            description: route.description,
+        }));
+        this.checkDuplicateOperationId(manifest);
+        return manifest;
+    }
     checkDuplicateAndPush(prefix, routerInfo) {
         const prefixList = this.routes.get(prefix);
         const matched = prefixList.filter(item => {
@@ -324,7 +408,25 @@ let MidwayWebRouterService = class MidwayWebRouterService {
                 item.requestMethod === routerInfo.requestMethod);
         });
         if (matched && matched.length) {
-            throw new error_1.MidwayDuplicateRouteError(`${routerInfo.requestMethod} ${routerInfo.url}`, `${matched[0].handlerName}`, `${routerInfo.handlerName}`);
+            const existingRoute = matched[0];
+            const fullPath = existingRoute.fullUrl ||
+                (typeof routerInfo.url === 'string'
+                    ? (0, util_1.joinURLPath)(prefix, routerInfo.url)
+                    : `${prefix}${routerInfo.url?.toString() || ''}`);
+            const payload = {
+                code: 'MIDWAY_DUPLICATE_ROUTE',
+                method: (routerInfo.requestMethod || '').toUpperCase(),
+                fullPath,
+                existing: {
+                    source: existingRoute.source ?? 'decorator',
+                    handler: this.getRouterHandlerIdentity(existingRoute),
+                },
+                current: {
+                    source: routerInfo.source ?? 'decorator',
+                    handler: this.getRouterHandlerIdentity(routerInfo),
+                },
+            };
+            throw new error_1.MidwayDuplicateRouteError(`${routerInfo.requestMethod} ${routerInfo.url}`, payload.existing.handler, payload.current.handler, payload);
         }
         // format url
         if (!routerInfo.fullUrlFlattenString &&
@@ -339,9 +441,59 @@ let MidwayWebRouterService = class MidwayWebRouterService {
             }
         }
         prefixList.push(routerInfo);
+        this.logRouteLoaded(routerInfo);
+    }
+    logRouteLoaded(routerInfo) {
+        const fullPath = routerInfo.fullUrl ||
+            (typeof routerInfo.url === 'string'
+                ? (0, util_1.joinURLPath)(routerInfo.prefix || '', routerInfo.url)
+                : `${routerInfo.prefix || ''}${routerInfo.url?.toString() || ''}`);
+        const logger = this.loggerService?.getLogger('appLogger');
+        if (!logger || typeof logger.info !== 'function') {
+            return;
+        }
+        logger.info('[midway:router] loaded route %s %s -> %s (%s)', (routerInfo.requestMethod || 'ALL').toUpperCase(), fullPath, this.getRouterHandlerIdentity(routerInfo), routerInfo.source ?? 'decorator');
+    }
+    getRouterHandlerIdentity(routerInfo) {
+        if (routerInfo.handlerName) {
+            return routerInfo.handlerName;
+        }
+        if (typeof routerInfo.method === 'string') {
+            return routerInfo.controllerId
+                ? `${routerInfo.controllerId}.${routerInfo.method}`
+                : routerInfo.method;
+        }
+        if (typeof routerInfo.method === 'function') {
+            return routerInfo.method.name || 'anonymous';
+        }
+        return 'unknown';
+    }
+    getOperationId(routeInfo) {
+        if (routeInfo.routerName) {
+            return routeInfo.routerName;
+        }
+        const fullPath = routeInfo.fullUrl || routeInfo.url?.toString() || '/';
+        return `${(routeInfo.requestMethod || 'all').toLowerCase()}_${fullPath
+            .toLowerCase()
+            .replace(/[^a-z0-9]+/g, '_')
+            .replace(/^_+|_+$/g, '')}`;
+    }
+    checkDuplicateOperationId(manifest) {
+        const operationMap = new Map();
+        for (const route of manifest) {
+            const exist = operationMap.get(route.operationId);
+            if (exist) {
+                throw new error_1.MidwayCommonError(`Duplicate operationId "${route.operationId}" between "${exist.method.toUpperCase()} ${exist.fullPath}" and "${route.method.toUpperCase()} ${route.fullPath}"`);
+            }
+            operationMap.set(route.operationId, route);
+        }
     }
 };
 exports.MidwayWebRouterService = MidwayWebRouterService;
+__decorate([
+    (0, decorator_1.Inject)(),
+    __metadata("design:type", loggerService_1.MidwayLoggerService)
+], MidwayWebRouterService.prototype, "loggerService", void 0);
 exports.MidwayWebRouterService = MidwayWebRouterService = __decorate([
     (0, decorator_1.Provide)(),
     (0, decorator_1.Scope)(interface_1.ScopeEnum.Singleton),

package/dist/setup.js

@@ -9,6 +9,7 @@ const config_default_1 = require("./config/config.default");
 const util = require("util");
 const slsFunctionService_1 = require("./service/slsFunctionService");
 const healthService_1 = require("./service/healthService");
+const traceService_1 = require("./service/traceService");
 const componentLoader_1 = require("./context/componentLoader");
 const util_1 = require("./util");
 const asyncContextManager_1 = require("./common/asyncContextManager");
@@ -48,6 +49,8 @@ async function initializeGlobalApplicationContext(globalOptions) {
         applicationContext,
         globalOptions,
     ]);
+    printStepDebugInfo('Init tracing');
+    await applicationContext.getAsync(traceService_1.MidwayTraceService);
     performanceManager_1.MidwayInitializerPerformanceManager.markEnd(performanceManager_1.MidwayInitializerPerformanceManager.MEASURE_KEYS.FRAMEWORK_PREPARE);
     printStepDebugInfo('Init lifecycle');
     performanceManager_1.MidwayInitializerPerformanceManager.markStart(performanceManager_1.MidwayInitializerPerformanceManager.MEASURE_KEYS.LIFECYCLE_PREPARE);
@@ -141,6 +144,7 @@ async function prepareGlobalApplicationContextAsync(globalOptions) {
     applicationContext.bindClass(slsFunctionService_1.MidwayServerlessFunctionService);
     applicationContext.bindClass(healthService_1.MidwayHealthService);
     applicationContext.bindClass(_1.MidwayPriorityManager);
+    applicationContext.bindClass(traceService_1.MidwayTraceService);
     printStepDebugInfo('Init MidwayConfigService, MidwayAspectService and MidwayDecoratorService');
     // init default environment
     const environmentService = applicationContext.get(_1.MidwayEnvironmentService);

package/dist/util/index.d.ts

@@ -29,6 +29,7 @@ export declare const loadModule: (p: string, options?: {
     safeLoad?: boolean;
     warnOnLoadError?: boolean;
     extraModuleRoot?: string[];
+    importQuery?: string;
 }) => Promise<any>;
 /**
  * load module sync, and it must be commonjs mode

package/dist/util/index.js

@@ -38,6 +38,79 @@ const pathFileUtil_1 = require("./pathFileUtil");
 const metadataManager_1 = require("../decorator/metadataManager");
 const decorator_1 = require("../decorator");
 const debug = (0, util_1.debuglog)('midway:debug');
+function resolveRelativeEsmSpecifierFallback(importerFile, specifier) {
+    if (!specifier ||
+        (!specifier.startsWith('./') && !specifier.startsWith('../'))) {
+        return undefined;
+    }
+    const absolute = (0, path_1.resolve)((0, path_1.dirname)(importerFile), specifier);
+    const candidates = [];
+    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`, (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'));
+    }
+    for (const item of candidates) {
+        if ((0, fs_1.existsSync)(item)) {
+            const normalized = item.split(path_1.sep).join('/');
+            const baseDir = (0, path_1.dirname)(importerFile).split(path_1.sep).join('/');
+            if (normalized.startsWith(baseDir + '/')) {
+                return './' + normalized.slice(baseDir.length + 1);
+            }
+            return specifier;
+        }
+    }
+    return undefined;
+}
+function rewriteEsmSourceWithSpecifierFallback(importerFile, source) {
+    let changed = false;
+    const rewriteByPattern = (pattern, input) => {
+        return input.replace(pattern, (full, head, spec, tail) => {
+            const fallback = resolveRelativeEsmSpecifierFallback(importerFile, spec);
+            if (!fallback || 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, fileUrl, importQuery) {
+    try {
+        return await import(fileUrl.href);
+    }
+    catch (originErr) {
+        const source = (0, fs_1.readFileSync)(p, { encoding: 'utf-8' });
+        const rewritten = rewriteEsmSourceWithSpecifierFallback(p, source);
+        if (rewritten === source) {
+            throw originErr;
+        }
+        const tmpFile = `${p}.mw-esm-fallback-${Date.now()}-${Math.random()
+            .toString(36)
+            .slice(2)}.ts`;
+        (0, fs_1.writeFileSync)(tmpFile, rewritten, { encoding: 'utf-8' });
+        try {
+            const tmpUrl = (0, url_1.pathToFileURL)(tmpFile);
+            if (importQuery) {
+                tmpUrl.searchParams.set('mwImportQuery', importQuery);
+            }
+            return await import(tmpUrl.href);
+        }
+        finally {
+            try {
+                (0, fs_1.unlinkSync)(tmpFile);
+            }
+            catch {
+                // ignore cleanup failure
+            }
+        }
+    }
+}
 /**
  * @since 2.0.0
  * @param env
@@ -121,7 +194,11 @@ const loadModule = async (p, options = {}) => {
                     return (await import(p, { with: { type: 'json' } })).default;
                 }
                 else {
-                    return await import((0, url_1.pathToFileURL)(p).href);
+                    const fileUrl = (0, url_1.pathToFileURL)(p);
+                    if (options.importQuery) {
+                        fileUrl.searchParams.set('mwImportQuery', options.importQuery);
+                    }
+                    return await importWithSpecifierFallback(p, fileUrl, options.importQuery);
                 }
             }
         }
@@ -540,7 +617,6 @@ function isTypeScriptEnvironment() {
     if ('false' === TS_MODE_PROCESS_FLAG) {
         return false;
     }
-    // eslint-disable-next-line node/no-deprecated-api
     return TS_MODE_PROCESS_FLAG === 'true' || !!require.extensions['.ts'];
 }
 function getFileNameWithSuffix(fileName) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@midwayjs/core",
-  "version": "4.0.0-beta.11",
+  "version": "4.0.0-beta.13",
   "description": "midway core",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -31,6 +31,7 @@
   },
   "dependencies": {
     "@midwayjs/glob": "^1.0.2",
+    "@opentelemetry/api": "1.9.0",
     "picomatch": "2.3.1",
     "reflect-metadata": "0.2.2"
   },
@@ -61,5 +62,5 @@
       "types": "./dist/functional/index.d.ts"
     }
   },
-  "gitHead": "6ef05719ca6e900f1ec34aff7a5c5a9614358c50"
+  "gitHead": "9a38b66a84a6880370cac90d737f94f9c5f2f256"
 }