@jcannon98188/vite-plugin-node 6.0.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Axe
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,32 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { Options } from "@swc/core";
+import type { Connect, UserConfig, ViteDevServer } from "vite";
+export { RollupPluginSwc } from "./rollup-plugin-swc.js";
+export { VitePluginNode } from "./vite-plugin-node.js";
+export declare const PLUGIN_NAME = "@jcannon98188/vite-plugin-node";
+export declare type SupportedFrameworks = "express" | "nest" | "koa" | "fastify" | "marble";
+export declare interface RequestAdapterParams<App> {
+    app: App;
+    server: ViteDevServer;
+    req: IncomingMessage;
+    res: ServerResponse;
+    next: Connect.NextFunction;
+}
+export declare type RequestAdapter<App = any> = (params: RequestAdapterParams<App>) => void | Promise<void>;
+export declare type RequestAdapterOption = SupportedFrameworks | RequestAdapter;
+export declare type SupportedTSCompiler = "esbuild" | "swc";
+export type InternalModuleFormat = "amd" | "cjs" | "es" | "iife" | "system" | "umd";
+export type ModuleFormat = InternalModuleFormat | "commonjs" | "esm" | "module" | "systemjs";
+export interface VitePluginNodeConfig {
+    appPath: string;
+    adapter: RequestAdapterOption;
+    appName?: string;
+    initAppOnBoot?: boolean;
+    exportName?: string;
+    tsCompiler?: SupportedTSCompiler;
+    swcOptions?: Options;
+    outputFormat?: ModuleFormat;
+}
+export declare interface ViteConfig extends UserConfig {
+    VitePluginNodeConfig: VitePluginNodeConfig;
+}

package/dist/index.js

@@ -0,0 +1,3 @@
+export { RollupPluginSwc } from "./rollup-plugin-swc.js";
+export { VitePluginNode } from "./vite-plugin-node.js";
+export const PLUGIN_NAME = "@jcannon98188/vite-plugin-node";

package/dist/rollup-plugin-swc.d.ts

@@ -0,0 +1,3 @@
+import type { Options } from "@swc/core";
+import type { Plugin } from "vite";
+export declare function RollupPluginSwc(options: Options): Plugin;

package/dist/rollup-plugin-swc.js

@@ -0,0 +1,28 @@
+import { createFilter } from "@rollup/pluginutils";
+import { cleanUrl } from "./utils.js";
+export function RollupPluginSwc(options) {
+    let swc;
+    // todo: load swc/tsconfig from config files
+    const config = {
+        // options from swc config
+        ...options,
+    };
+    const filter = createFilter(/\.(tsx?|jsx)$/, /\.js$/);
+    return {
+        name: "rollup-plugin-swc",
+        async transform(code, id) {
+            if (filter(id) || filter(cleanUrl(id))) {
+                if (!swc)
+                    swc = await import("@swc/core").then(({ Compiler }) => new Compiler());
+                const result = await swc.transform(code, {
+                    ...config,
+                    filename: id,
+                });
+                return {
+                    code: result.code,
+                    map: result.map,
+                };
+            }
+        },
+    };
+}

package/dist/server/express.d.ts

@@ -0,0 +1,3 @@
+import type { Application } from "express";
+import type { RequestAdapter } from "../index.js";
+export declare const ExpressHandler: RequestAdapter<Application>;

package/dist/server/express.js

@@ -0,0 +1,3 @@
+export const ExpressHandler = ({ app, req, res, }) => {
+    app(req, res);
+};

package/dist/server/fastify.d.ts

@@ -0,0 +1,3 @@
+import type { FastifyInstance } from "fastify";
+import type { RequestAdapter } from "../index.js";
+export declare const FastifyHandler: RequestAdapter<FastifyInstance>;

package/dist/server/fastify.js

@@ -0,0 +1,4 @@
+export const FastifyHandler = async ({ app, req, res, }) => {
+    await app.ready();
+    app.routing(req, res);
+};

package/dist/server/index.d.ts

@@ -0,0 +1,13 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { Connect, ViteDevServer } from "vite";
+import type { RequestAdapter, VitePluginNodeConfig } from "../index.js";
+export declare const debugServer: (msg: string, ...args: unknown[]) => void;
+export declare const SUPPORTED_FRAMEWORKS: {
+    express: RequestAdapter<import("express").Application>;
+    nest: RequestAdapter<import("@nestjs/common").INestApplication>;
+    koa: RequestAdapter<import("koa")<import("koa").DefaultState, import("koa").DefaultContext>>;
+    fastify: RequestAdapter<import("fastify").FastifyInstance<import("fastify").RawServerDefault, IncomingMessage, ServerResponse<IncomingMessage>, import("fastify").FastifyLoggerInstance>>;
+    marble: RequestAdapter<import("./marble.js").MarbleContext>;
+};
+export declare const getPluginConfig: (server: ViteDevServer) => Promise<VitePluginNodeConfig>;
+export declare const createMiddleware: (server: ViteDevServer) => Promise<Connect.HandleFunction>;

package/dist/server/index.js

@@ -0,0 +1,71 @@
+import { exit } from "node:process";
+import chalk from "chalk";
+import { PLUGIN_NAME } from "../index.js";
+import { createDebugger } from "../utils.js";
+import { ExpressHandler } from "./express.js";
+import { FastifyHandler } from "./fastify.js";
+import { KoaHandler } from "./koa.js";
+import { MarbleHandler } from "./marble.js";
+import { NestHandler } from "./nest.js";
+export const debugServer = createDebugger("vite:node-plugin:server");
+export const SUPPORTED_FRAMEWORKS = {
+    express: ExpressHandler,
+    nest: NestHandler,
+    koa: KoaHandler,
+    fastify: FastifyHandler,
+    marble: MarbleHandler,
+};
+const env = { command: "serve", mode: "" };
+export const getPluginConfig = async (server) => {
+    const plugin = server.config.plugins.find((p) => p.name === PLUGIN_NAME);
+    let userConfig = null;
+    if (typeof plugin.config === "function")
+        userConfig = (await plugin.config({}, env)) ?? undefined;
+    if (userConfig)
+        return userConfig.VitePluginNodeConfig;
+    console.error("Please setup VitePluginNode in your vite.config.js first");
+    exit(1);
+};
+const getRequestHandler = (handler) => {
+    if (typeof handler === "function") {
+        debugServer(chalk.dim `using custom server handler`);
+        return handler;
+    }
+    debugServer(chalk.dim `creating ${handler} node server`);
+    return SUPPORTED_FRAMEWORKS[handler];
+};
+export const createMiddleware = async (server) => {
+    const config = await getPluginConfig(server);
+    const logger = server.config.logger;
+    const requestHandler = getRequestHandler(config.adapter);
+    async function _loadApp(config) {
+        const appModule = await server.ssrLoadModule(config.appPath);
+        if (!config.exportName) {
+            throw new Error("exportName is required in VitePluginNodeConfig");
+        }
+        let app = appModule[config.exportName];
+        if (!app) {
+            logger.error(`Failed to find a named export ${config.exportName} from ${config.appPath}`);
+            process.exit(1);
+        }
+        else {
+            // some app may be created with a function returning a promise
+            app = await app;
+            return app;
+        }
+    }
+    if (!requestHandler) {
+        console.error("Failed to find a request handler");
+        process.exit(1);
+    }
+    if (config.initAppOnBoot) {
+        server.httpServer?.once("listening", async () => {
+            await _loadApp(config);
+        });
+    }
+    return async (req, res, next) => {
+        const app = await _loadApp(config);
+        if (app)
+            await requestHandler({ app, server, req, res, next });
+    };
+};

package/dist/server/koa.d.ts

@@ -0,0 +1,3 @@
+import type Koa from "koa";
+import type { RequestAdapter } from "../index.js";
+export declare const KoaHandler: RequestAdapter<Koa>;

package/dist/server/koa.js

@@ -0,0 +1,3 @@
+export const KoaHandler = ({ app, req, res }) => {
+    app.callback()(req, res);
+};

package/dist/server/marble.d.ts

@@ -0,0 +1,9 @@
+import type { Context, ServerIO } from "@marblejs/core";
+import type { HttpListener, HttpServer } from "@marblejs/http";
+import type { Reader } from "fp-ts/Reader";
+import type { RequestAdapter } from "../index.js";
+export interface MarbleContext {
+    server: Promise<ServerIO<HttpServer>>;
+    listener: Reader<Context, HttpListener>;
+}
+export declare const MarbleHandler: RequestAdapter<MarbleContext>;

package/dist/server/marble.js

@@ -0,0 +1,4 @@
+export const MarbleHandler = async ({ app, req, res, }) => {
+    const server = await app.server;
+    app.listener(server.context)(req, res);
+};

package/dist/server/nest.d.ts

@@ -0,0 +1,3 @@
+import type { INestApplication } from "@nestjs/common";
+import type { RequestAdapter } from "../index.js";
+export declare const NestHandler: RequestAdapter<INestApplication>;

package/dist/server/nest.js

@@ -0,0 +1,18 @@
+let prevApp;
+export const NestHandler = async ({ app, req, res, }) => {
+    // @ts-expect-error nest app typing error
+    if (!app.isInitialized) {
+        if (prevApp)
+            await prevApp.close();
+        await app.init();
+        prevApp = app;
+    }
+    const instance = app.getHttpAdapter().getInstance();
+    if (typeof instance === "function") {
+        instance(req, res);
+    }
+    else {
+        const fastifyApp = await instance.ready();
+        fastifyApp.routing(req, res);
+    }
+};

package/dist/utils.d.ts

@@ -0,0 +1,6 @@
+export declare function createDebugger(ns: string): (msg: string, ...args: unknown[]) => void;
+export declare const queryRE: RegExp;
+export declare const hashRE: RegExp;
+export declare const cleanUrl: (url: string) => string;
+export declare function isObject(item: any): item is object;
+export default function mergeDeep(target: object, source: object): object;

package/dist/utils.js

@@ -0,0 +1,40 @@
+/**
+ * modified from vitejs source code, just to make the console output looks vite-like
+ */
+import debug from "debug";
+export function createDebugger(ns) {
+    const log = debug(ns);
+    return (msg, ...args) => {
+        log(msg, ...args);
+    };
+}
+export const queryRE = /\?.*$/;
+export const hashRE = /#.*$/;
+export const cleanUrl = (url) => url.replace(hashRE, "").replace(queryRE, "");
+// biome-ignore lint/suspicious/noExplicitAny: Function is a typeguard.
+export function isObject(item) {
+    return item && typeof item === "object" && !Array.isArray(item);
+}
+export default function mergeDeep(target, source) {
+    const output = Object.assign({}, target);
+    if (isObject(target) && isObject(source)) {
+        for (const key of Object.keys(source)) {
+            // @ts-expect-error access unknow property
+            if (isObject(source[key])) {
+                if (!(key in target)) {
+                    // @ts-expect-error access unknow property
+                    Object.assign(output, { [key]: source[key] });
+                }
+                else {
+                    // @ts-expect-error access unknow property
+                    output[key] = mergeDeep(target[key], source[key]);
+                }
+            }
+            else {
+                // @ts-expect-error access unknow property
+                Object.assign(output, { [key]: source[key] });
+            }
+        }
+    }
+    return output;
+}

package/dist/vite-plugin-node.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from "vite";
+import { type VitePluginNodeConfig } from "./index.js";
+export declare function VitePluginNode(cfg: VitePluginNodeConfig): Plugin[];

package/dist/vite-plugin-node.js

@@ -0,0 +1,75 @@
+import { PLUGIN_NAME } from "./index.js";
+import { RollupPluginSwc } from "./rollup-plugin-swc.js";
+import { createMiddleware } from "./server/index.js";
+import mergeDeep from "./utils.js";
+export function VitePluginNode(cfg) {
+    const swcOptions = mergeDeep({
+        module: {
+            type: "es6",
+        },
+        jsc: {
+            target: "es2019",
+            parser: {
+                syntax: "typescript",
+                decorators: true,
+            },
+            transform: {
+                legacyDecorator: true,
+                decoratorMetadata: true,
+            },
+        },
+    }, cfg.swcOptions ?? {});
+    const config = {
+        appPath: cfg.appPath,
+        adapter: cfg.adapter,
+        appName: cfg.appName ?? "app",
+        tsCompiler: cfg.tsCompiler ?? "swc",
+        exportName: cfg.exportName ?? "viteNodeApp",
+        initAppOnBoot: cfg.initAppOnBoot ?? false,
+        outputFormat: cfg.outputFormat ?? "module",
+        swcOptions,
+    };
+    const plugins = [
+        {
+            name: PLUGIN_NAME,
+            config: () => {
+                const plugincConfig = {
+                    build: {
+                        ssr: config.appPath,
+                        rollupOptions: {
+                            input: config.appPath,
+                            output: {
+                                format: config.outputFormat,
+                            },
+                        },
+                    },
+                    server: {
+                        hmr: false,
+                    },
+                    optimizeDeps: {
+                        noDiscovery: true,
+                        // Vite does not work well with optionnal dependencies,
+                        // mark them as ignored for now
+                        exclude: ["@swc/core"],
+                    },
+                    VitePluginNodeConfig: config,
+                };
+                if (config.tsCompiler === "swc")
+                    plugincConfig.esbuild = false;
+                return plugincConfig;
+            },
+            configureServer: async (server) => {
+                server.middlewares.use(await createMiddleware(server));
+            },
+        },
+    ];
+    if (config.tsCompiler === "swc") {
+        if (!config.swcOptions) {
+            throw new Error("swcOptions is required when using swc as tsCompiler");
+        }
+        plugins.push({
+            ...RollupPluginSwc(config.swcOptions),
+        });
+    }
+    return plugins;
+}

package/package.json

@@ -0,0 +1,64 @@
+{
+	"name": "@jcannon98188/vite-plugin-node",
+	"version": "6.0.2",
+	"description": "Vite plugin to enable your node server HMR, forked and maintained by jcannon98188",
+	"author": "Axe, Fork by Jason Cannon",
+	"license": "MIT",
+	"type": "module",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/jcannon98188/vite-plugin-node.git"
+	},
+	"bugs": {
+		"url": "https://github.com/jcannon98188/vite-plugin-node/issues"
+	},
+	"homepage": "https://github.com/jcannon98188/vite-plugin-node#readme",
+	"keywords": ["vite", "vite-plugin", "node", "hmr"],
+	"main": "dist/index.js",
+	"files": ["dist", "readme.md"],
+	"scripts": {
+		"build-dist": "tsc",
+		"build": "run-s prebuild build-dist",
+		"dev": "tsc -w --incremental",
+		"lint": "npx @biomejs/biome lint --write .",
+		"format": "npx @biomesjs/biome format --write .",
+		"prebuild": "rimraf dist && npm run lint && cp ../../README.md ./readme.md"
+	},
+	"dependencies": {
+		"@rollup/pluginutils": "^5.1.4",
+		"chalk": "^4.1.2",
+		"debug": "^4.3.2"
+	},
+	"peerDependencies": {
+		"@swc/core": "^1.7.26",
+		"vite": "^6.0.0"
+	},
+	"peerDependenciesMeta": {
+		"@swc/core": {
+			"optional": true
+		}
+	},
+	"devDependencies": {
+		"@biomejs/biome": "1.9.4",
+		"@marblejs/core": "^4.0.2",
+		"@marblejs/http": "^4.0.2",
+		"@nestjs/common": "^8.0.9",
+		"@swc/core": "^1.7.26",
+		"@types/debug": "^4.1.7",
+		"@types/estree": "^0.0.50",
+		"@types/express": "^4.17.13",
+		"@types/koa": "^2.13.4",
+		"@types/node": "^18.19.55",
+		"@types/rx": "^4.1.2",
+		"express": "^4.17.1",
+		"fastify": "^3.22.0",
+		"fp-ts": "^2.8.2",
+		"koa": "^2.13.3",
+		"npm-run-all": "^4.1.5",
+		"reflect-metadata": "^0.1.13",
+		"rimraf": "^3.0.2",
+		"rxjs": "^7.5.5",
+		"typescript": "^5.7.3",
+		"vite": "^6.1.0"
+	}
+}

package/readme.md

@@ -0,0 +1,180 @@
+<p align="center">
+  <img src="./node-vite.png" width="200px">
+</p>
+<p align="center">
+  <a href="https://www.npmjs.com/package/@jcannon98188/vite-plugin-node"><img src="https://img.shields.io/npm/v/@jcannon98188/vite-plugin-node.svg" alt="npm package"></a>
+  <a href="https://nodejs.org/en/about/releases/"><img src="https://img.shields.io/node/v/@jcannon98188/vite-plugin-node.svg" alt="node compatibility"></a>
+</p>
+
+# Vite Plugin Node
+
+> A [vite](https://vitejs.dev/) plugin to allow you to use vite as node dev server.
+
+## Features
+
+- All the perks from Vite plus:
+- Node server HMR! (hot module replacement)
+- Support Express, Fastify, Koa and Nest out of the box
+- Support Custom Request Adapter
+- You can choose to use `esbuild` or `swc` to compile your typescript files
+
+## Get started
+
+---
+
+1. Install vite and this plugin with your favorite package manager, here use npm as example:
+
+   ```bash
+   npm install vite @jcannon98188/vite-plugin-node -D
+   ```
+
+2. Create a `vite.config.ts` file in your project root to config vite to actually use this plugin:
+
+   ```ts
+   import { defineConfig } from 'vite';
+   import { VitePluginNode } from '@jcannon98188/vite-plugin-node';
+
+   export default defineConfig({
+     // ...vite configures
+     server: {
+       // vite server configs, for details see [vite doc](https://vitejs.dev/config/#server-host)
+       port: 3000
+     },
+     plugins: [
+       ...VitePluginNode({
+         // Nodejs native Request adapter
+         // currently this plugin support 'express', 'nest', 'koa' and 'fastify' out of box,
+         // you can also pass a function if you are using other frameworks, see Custom Adapter section
+         adapter: 'express',
+
+         // tell the plugin where is your project entry
+         appPath: './app.ts',
+
+         // Optional, default: 'viteNodeApp'
+         // the name of named export of you app from the appPath file
+         exportName: 'viteNodeApp',
+
+         // Optional, default: false
+         // if you want to init your app on boot, set this to true
+         initAppOnBoot: false,
+
+         // Optional, default: 'esbuild'
+         // The TypeScript compiler you want to use
+         // by default this plugin is using vite default ts compiler which is esbuild
+         // 'swc' compiler is supported to use as well for frameworks
+         // like Nestjs (esbuild dont support 'emitDecoratorMetadata' yet)
+         // you need to INSTALL `@swc/core` as dev dependency if you want to use swc
+         tsCompiler: 'esbuild',
+
+         // Optional, default: {
+         // jsc: {
+         //   target: 'es2019',
+         //   parser: {
+         //     syntax: 'typescript',
+         //     decorators: true
+         //   },
+         //  transform: {
+         //     legacyDecorator: true,
+         //     decoratorMetadata: true
+         //   }
+         // }
+         // }
+         // swc configs, see [swc doc](https://swc.rs/docs/configuration/swcrc)
+         swcOptions: {}
+       })
+     ],
+   });
+   ```
+
+3. Update your server entry to export your app named `viteNodeApp` or the name you configured.
+
+### [ExpressJs](./examples/express/app.ts)
+
+```ts
+const app = express();
+
+// your beautiful code...
+
+if (import.meta.env.PROD)
+  app.listen(3000);
+
+export const viteNodeApp = app;
+```
+#### More Examples:
+- [KoaJs](./examples/koa/app.ts)
+- [Cloud Functions](./examples/cloudfunction/app.ts)
+- [Fastify](./examples/fastify/app.ts)
+- [NestJs](./examples/nest/src/main.ts)
+- [Apollo Server](./examples/apollo/app.ts)
+
+4. Add a npm script to run the dev server:
+
+   ```json
+   "scripts": {
+     "dev": "vite"
+   },
+   ```
+
+5. Run the script! `npm run dev`
+
+## Custom Adapter
+
+If your favorite framework not supported yet, you can either create an issue to request it or use the `adapter` option to tell the plugin how to pass down the request to your app. You can take a look how the supported frameworks implementations from the `./src/server` folder.
+Example:
+
+```ts
+import { defineConfig } from 'vite';
+import { VitePluginNode } from '@jcannon98188/vite-plugin-node';
+
+export default defineConfig({
+  plugins: [
+    ...VitePluginNode({
+      adapter({ app, server, req, res, next }) {
+        app(res, res);
+      },
+      appPath: './app.ts'
+    })
+  ]
+});
+```
+
+## Build
+This plugin leverages Vite SSR mode to build your app. All you need to do is add a build script to your package.json:
+
+   ```json
+   "scripts": {
+     "build": "vite build"
+   },
+   ```
+For more build config please check [vite doc](https://vitejs.dev/config/#build-target)
+
+> Note: By default, starting from vite v3, the ssr buildle will be in esm format. if you want to build cjs, add `ssr: { format: 'cjs' }` to your vite config.
+
+## Examples
+
+See the examples folder.
+
+## Why?
+
+---
+
+While frontend development tooling is evolving rapidly in recent years, backend DX is still like in stone age. No hot module replacement; Typescript recompiling slow as funk; Lack of plugin system etc. Thanks to Vite.js created by Evan You (A.K.A creator of vue.js; my biggest idol developer), makes all those dreams for backend development come true!
+
+## How?
+
+---
+
+Vite by design has a middleware mode, which allows us to use it programmatically inside other modules. It's originally made for SSR, so that for each request, vite can load the renderer and render the latest changes you made to your app (<https://vitejs.dev/guide/ssr.html>). This plugin leverages this feature to load and execute your server app entry.
+
+You may ask, isn't super slow, since it re-compiles/reloads the entire app? The answer is NO, because vite is smart. It has a builtin module graph as a cache layer, the graph is built up the first time your app loads. After that, when you update a file, vite will only invalidate that one and its parent modules, so that for next request, only those invalidated modules need to be re-compiled which is super fast thanks to esbuild or swc.
+
+## To-Do
+
+As this plugin just fresh developed, there are still lots ideas need to be implemented, including:
+
+- [ ] Test with a large node project, I need y'all helps on this!
+- [ ] Unit tests
+
+## Bugs
+
+Please create an issue if you found any bugs, to help me improve this project!