@midwayjs/mock 4.0.0-beta.11 → 4.0.0-beta.12

package/dist/creator.js

@@ -479,7 +479,6 @@ class BootstrapAppStarter {
         return applicationManager.getApplication(type);
     }
     async close(options = {}) {
-        // eslint-disable-next-line node/no-extraneous-require
         const BootstrapModule = await (0, core_1.loadModule)('@midwayjs/bootstrap', {
             loadMode: this.options.moduleLoadType,
             safeLoad: true,

package/dist/vite.d.ts

@@ -0,0 +1,33 @@
+interface RouteManifestLike {
+    source: string;
+    operationId: string;
+    controllerId?: string;
+    controllerPrefix: string;
+    method: string;
+    path: string;
+    fullPath: string;
+    routerName?: string;
+}
+export interface DevPluginOptions {
+    appDir: string;
+    baseDir?: string;
+    basePath?: string;
+    watch?: {
+        include?: RegExp[];
+        exclude?: RegExp[];
+    };
+    getRequestHandler?: (app: any) => (req: any, res: any, next?: () => void) => any;
+    routeManifest?: boolean | {
+        virtualId?: string;
+        filter?: (route: RouteManifestLike) => boolean;
+    };
+}
+export declare function devPlugin(options: DevPluginOptions): {
+    name: string;
+    apply: string;
+    resolveId(source: string): string;
+    load(id: string): Promise<string>;
+    configureServer(server: any): Promise<void>;
+};
+export {};
+//# sourceMappingURL=vite.d.ts.map

package/dist/vite.js

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.devPlugin = devPlugin;
+const creator_1 = require("./creator");
+const node_path_1 = require("node:path");
+const core_1 = require("@midwayjs/core");
+const DEFAULT_ROUTE_MANIFEST_VIRTUAL_ID = 'virtual:midway-route-manifest';
+function startsWithBasePath(url, basePath) {
+    if (basePath === '/') {
+        return true;
+    }
+    return url === basePath || url.startsWith(`${basePath}/`);
+}
+function getDefaultRequestHandler(app) {
+    if (app && typeof app.callback === 'function') {
+        return app.callback();
+    }
+    if (typeof app === 'function') {
+        return app;
+    }
+    if (app && typeof app.getFramework === 'function') {
+        const framework = app.getFramework();
+        if (framework) {
+            const frameworkApp = typeof framework.getApplication === 'function'
+                ? framework.getApplication()
+                : undefined;
+            if (frameworkApp && typeof frameworkApp.callback === 'function') {
+                return frameworkApp.callback();
+            }
+            if (typeof framework.callback2 === 'function') {
+                return framework.callback2();
+            }
+        }
+    }
+    throw new Error('[midway:mock] can not resolve request handler, please provide getRequestHandler in devPlugin options');
+}
+function devPlugin(options) {
+    if (!options?.appDir) {
+        throw new Error('[midway:mock] devPlugin requires "appDir", e.g. devPlugin({ appDir: process.cwd() })');
+    }
+    const appDir = options.appDir;
+    const baseDir = options.baseDir
+        ? (0, node_path_1.resolve)(appDir, options.baseDir)
+        : (0, node_path_1.resolve)(appDir, 'src');
+    const resolvedBaseDir = baseDir;
+    const basePath = options.basePath || '/api';
+    const watchInclude = options.watch?.include || [/\.(ts|tsx|js|mjs|cjs)$/];
+    const watchExclude = options.watch?.exclude || [/\.d\.ts$/];
+    const getRequestHandler = options.getRequestHandler || getDefaultRequestHandler;
+    const routeManifestOptions = options.routeManifest && typeof options.routeManifest === 'object'
+        ? options.routeManifest
+        : undefined;
+    const routeManifestEnabled = options.routeManifest !== false;
+    const routeManifestVirtualId = routeManifestOptions?.virtualId || DEFAULT_ROUTE_MANIFEST_VIRTUAL_ID;
+    const routeManifestResolvedId = `\0${routeManifestVirtualId}`;
+    const routeManifestFilter = routeManifestOptions?.filter;
+    let appPromise = null;
+    let routeManifestPromise = null;
+    let reloadingAppPromise = null;
+    let viteServer;
+    const invalidateRouteManifestModule = () => {
+        if (!routeManifestEnabled || !viteServer) {
+            return;
+        }
+        const mod = viteServer.moduleGraph?.getModuleById(routeManifestResolvedId);
+        if (mod) {
+            viteServer.moduleGraph.invalidateModule(mod);
+            viteServer.ws?.send({
+                type: 'full-reload',
+            });
+        }
+    };
+    const shouldReloadFile = (file) => {
+        if (!file.startsWith(resolvedBaseDir)) {
+            return false;
+        }
+        if (watchExclude.some(reg => reg.test(file))) {
+            return false;
+        }
+        return watchInclude.some(reg => reg.test(file));
+    };
+    const reloadApp = async () => {
+        if (reloadingAppPromise) {
+            return reloadingAppPromise;
+        }
+        reloadingAppPromise = (async () => {
+            const oldAppPromise = appPromise;
+            appPromise = null;
+            routeManifestPromise = null;
+            if (oldAppPromise) {
+                const oldApp = await oldAppPromise;
+                await (0, creator_1.close)(oldApp);
+            }
+            invalidateRouteManifestModule();
+        })().finally(() => {
+            reloadingAppPromise = null;
+        });
+        return reloadingAppPromise;
+    };
+    const ensureApp = async () => {
+        if (!appPromise) {
+            appPromise = (0, creator_1.createApp)({
+                appDir,
+                baseDir,
+            });
+        }
+        return appPromise;
+    };
+    const ensureRouteManifest = async () => {
+        if (!routeManifestEnabled) {
+            return [];
+        }
+        if (!routeManifestPromise) {
+            routeManifestPromise = (async () => {
+                const app = await ensureApp();
+                const appContext = app.getApplicationContext?.();
+                if (!appContext) {
+                    throw new Error('[midway:mock] can not resolve applicationContext for route manifest generation');
+                }
+                const webRouterService = await appContext.getAsync(core_1.MidwayWebRouterService);
+                let manifest = await webRouterService.getRouteManifest();
+                if (typeof routeManifestFilter === 'function') {
+                    manifest = manifest.filter(routeManifestFilter);
+                }
+                return manifest;
+            })();
+        }
+        return routeManifestPromise;
+    };
+    return {
+        name: 'midway-dev-runtime',
+        apply: 'serve',
+        resolveId(source) {
+            if (!routeManifestEnabled) {
+                return null;
+            }
+            if (source === routeManifestVirtualId) {
+                return routeManifestResolvedId;
+            }
+            return null;
+        },
+        async load(id) {
+            if (!routeManifestEnabled || id !== routeManifestResolvedId) {
+                return null;
+            }
+            const manifest = await ensureRouteManifest();
+            return `export default ${JSON.stringify(manifest)};`;
+        },
+        async configureServer(server) {
+            viteServer = server;
+            server.httpServer?.once('close', async () => {
+                await reloadApp();
+            });
+            server.watcher.on('all', async (eventName, file) => {
+                if (eventName !== 'add' &&
+                    eventName !== 'change' &&
+                    eventName !== 'unlink') {
+                    return;
+                }
+                if (!shouldReloadFile(file)) {
+                    return;
+                }
+                server.config.logger.info(`[midway:mock] detected server ${eventName}, reload midway app: ${file}`);
+                await reloadApp();
+            });
+            server.middlewares.use(async (req, res, next) => {
+                const originalUrl = req.url || '';
+                const pathname = originalUrl.split('?')[0];
+                if (!startsWithBasePath(pathname, basePath)) {
+                    next();
+                    return;
+                }
+                const app = await ensureApp();
+                const handler = getRequestHandler(app);
+                return handler(req, res, next);
+            });
+        },
+    };
+}
+//# sourceMappingURL=vite.js.map

package/package.json

@@ -1,9 +1,21 @@
 {
   "name": "@midwayjs/mock",
-  "version": "4.0.0-beta.11",
+  "version": "4.0.0-beta.12",
   "description": "create your test app from midway framework",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
+      "import": "./dist/index.js"
+    },
+    "./vite": {
+      "types": "./dist/vite.d.ts",
+      "require": "./dist/vite.js",
+      "import": "./dist/vite.js"
+    }
+  },
   "scripts": {
     "build": "tsc",
     "test": "node -r ts-node/register ../../node_modules/jest/bin/jest.js --runInBand",
@@ -29,7 +41,7 @@
   },
   "license": "MIT",
   "devDependencies": {
-    "@midwayjs/core": "^4.0.0-beta.11",
+    "@midwayjs/core": "^4.0.0-beta.12",
     "@midwayjs/logger": "^4.0.0",
     "@types/amqplib": "0.10.8",
     "amqplib": "0.10.9",
@@ -50,5 +62,5 @@
     "type": "git",
     "url": "https://github.com/midwayjs/midway.git"
   },
-  "gitHead": "6ef05719ca6e900f1ec34aff7a5c5a9614358c50"
+  "gitHead": "1c48179b7c827ba8ec9351e9b6c36ec1726d3e11"
 }