@davnx/webpack 1.0.0

package/README.md

@@ -0,0 +1,390 @@
+# @davnx/webpack
+
+[![npm](https://img.shields.io/npm/v/@davnx/webpack)](https://www.npmjs.com/package/@davnx/webpack)
+[![license](https://img.shields.io/npm/l/@davnx/webpack)](./LICENSE)
+
+Custom Nx executors for building and serving NestJS applications with webpack. Includes a multi-process development server with hot module reload and round-robin load balancing.
+
+## Installation
+
+```bash
+npm install -D @davnx/webpack
+# or
+yarn add -D @davnx/webpack
+```
+
+**Peer dependencies** (must be installed in your workspace):
+
+- `webpack` ^5.0.0
+- `@nx/webpack` >=20.0.0
+- `@nx/devkit` >=20.0.0
+
+## Quick Start
+
+Add the executors to your NestJS app's `project.json`:
+
+```json
+{
+  "targets": {
+    "build": {
+      "executor": "@davnx/webpack:build",
+      "dependsOn": ["^build"],
+      "options": {
+        "entryFile": "./src/deployments/service/main.ts",
+        "tsConfigFile": "./tsconfig.app.json",
+        "orgScopes": ["@myorg"]
+      }
+    },
+    "serve": {
+      "executor": "@davnx/webpack:serve",
+      "options": {
+        "entryFile": "./src/deployments/service/main.ts",
+        "tsConfigFile": "./tsconfig.app.json",
+        "orgScopes": ["@myorg"]
+      }
+    }
+  }
+}
+```
+
+Then run:
+
+```bash
+nx serve my-app    # Development with hot reload
+nx build my-app    # Production build
+```
+
+## Executors
+
+### `@davnx/webpack:build`
+
+Production webpack build for NestJS applications. Compiles your application with full type checking, tree shaking, and generates a deployable `package.json`.
+
+#### Options
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `entryFile` | `string` | `./src/deployments/service/main.ts` | Entry point file (relative to project root) |
+| `tsConfigFile` | `string` | `./tsconfig.app.json` | TypeScript config file |
+| `outputPath` | `string` | `dist/{projectRoot}` | Output directory (relative to workspace root) |
+| `assets` | `string[]` | `[]` | Static assets to copy to the output |
+| `additionalEntryPoints` | `object[]` | `[]` | Extra webpack entry points (`{ entryName, entryPath }`) |
+| `runtimeDependencies` | `string[]` | `[]` | Extra dependencies for the generated `package.json` |
+| `ormConfigPath` | `string` | auto-detect | Path to `ormconfig.ts` (empty string to disable) |
+| `migrationsDir` | `string` | `./src/migrations` | TypeORM migrations directory |
+| `memoryLimit` | `number` | `8192` | Memory limit (MB) for the TypeScript type checker |
+| `generatePackageJson` | `boolean` | `true` | Generate a `package.json` in the output directory |
+| `buildLibsFromSource` | `boolean` | `false` | Read workspace libraries from source instead of pre-built dist |
+| `orgScopes` | `string[]` | `[]` | Org scopes to bundle into the output (e.g. `["@myorg"]`) |
+| `bundlePackages` | `string[]` | `[]` | Explicit package names to force-bundle (e.g. `["lodash"]`) |
+| `nodeExternalsConfig` | `object` | `{}` | Override options for `webpack-node-externals` (see [Externals Configuration](#externals-configuration)) |
+| `webpackConfigPath` | `string` | — | Path to a JS/TS file exporting a `(config) => config` override function (see [Webpack Overrides](#webpack-overrides)) |
+
+#### TypeORM Support
+
+If an `ormconfig.ts` file is detected in `src/ormconfig.ts` (or at the path specified by `ormConfigPath`), the build executor automatically creates a second webpack compilation that bundles:
+
+- `ormconfig.js` — the TypeORM CLI configuration
+- `migrations/*.js` — all migration files from `migrationsDir`
+
+This allows running TypeORM CLI commands (`typeorm migration:run`) directly against the production build output.
+
+#### Example: Full Configuration
+
+```json
+{
+  "build": {
+    "executor": "@davnx/webpack:build",
+    "dependsOn": ["^build"],
+    "options": {
+      "entryFile": "./src/deployments/service/main.ts",
+      "tsConfigFile": "./tsconfig.app.json",
+      "outputPath": "dist/apps/my-api",
+      "orgScopes": ["@myorg"],
+      "additionalEntryPoints": [
+        { "entryName": "worker", "entryPath": "./src/deployments/worker/main.ts" }
+      ],
+      "runtimeDependencies": ["pg", "redis"],
+      "assets": ["apps/my-api/src/assets"]
+    }
+  }
+}
+```
+
+### `@davnx/webpack:serve`
+
+Development server with webpack watch mode, async type checking, and an integrated multi-process HTTP server with hot module reload.
+
+#### Options
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `entryFile` | `string` | `./src/deployments/service/main.ts` | Entry point file |
+| `tsConfigFile` | `string` | `./tsconfig.app.json` | TypeScript config file |
+| `outputPath` | `string` | `dist/{projectRoot}` | Output directory |
+| `assets` | `string[]` | `[]` | Static assets to copy |
+| `configEnv` | `string` | `development` | Config YAML environment (`config/config.{env}.yaml`) |
+| `memoryLimit` | `number` | `8192` | Memory limit (MB) for the TypeScript type checker |
+| `childCount` | `number` | `1` | Number of child worker processes |
+| `buildLibsFromSource` | `boolean` | `true` | Read workspace libraries from source for faster dev builds |
+| `orgScopes` | `string[]` | `[]` | Org scopes to bundle (e.g. `["@myorg"]`) |
+| `bundlePackages` | `string[]` | `[]` | Explicit package names to force-bundle (e.g. `["lodash"]`) |
+| `nodeExternalsConfig` | `object` | `{}` | Override options for `webpack-node-externals` (see [Externals Configuration](#externals-configuration)) |
+| `webpackConfigPath` | `string` | — | Path to a JS/TS file exporting a `(config) => config` override function (see [Webpack Overrides](#webpack-overrides)) |
+
+#### How the Dev Server Works
+
+The serve executor runs a multi-process architecture:
+
+```
+┌─────────────────────────────────────────────┐
+│  Webpack (watch mode)                       │
+│  Compiles on file change → triggers reload  │
+└──────────────┬──────────────────────────────┘
+               │ POST /webpack/reload
+               ▼
+┌─────────────────────────────────────────────┐
+│  Parent Process (port from config YAML)     │
+│  Round-robin load balancer                  │
+│  Service prefix enforcement                 │
+├────────────┬────────────────────────────────┤
+│ Child #1   │ Child #2   │ ... Child #N      │
+│ NestJS app │ NestJS app │ NestJS app        │
+│ Unix sock  │ Unix sock  │ Unix sock         │
+└────────────┴────────────┴───────────────────┘
+```
+
+1. **Webpack watches** for file changes and recompiles
+2. On successful build, a **reload signal** is sent to the parent process
+3. The parent forwards the reload to all **child processes** via IPC
+4. Each child **hot-swaps** the NestJS application in-process (no restart needed)
+5. Incoming HTTP requests are **round-robin proxied** to healthy children
+6. If a child crashes, the parent **respawns** it automatically
+
+#### Config Resolution
+
+The serve executor reads `config/config.{configEnv}.yaml` from the workspace root to resolve:
+
+- `port` — the port the dev server listens on (default: `3050`)
+- `serviceName` — used for URL prefix enforcement and socket naming
+
+```yaml
+# config/config.development.yaml
+port: 3050
+serviceName: my-api
+```
+
+With `serviceName: my-api`, the devserver enforces that all requests start with `/my-api/`, mimicking production gateway behavior. Requests without the prefix return 404.
+
+## NestJS Bootstrap Contract
+
+Your application's entry point must implement a dual-mode bootstrap pattern to support both standalone production and devserver development modes.
+
+### How It Works
+
+| Mode | Trigger | Behavior |
+|------|---------|----------|
+| **Production** | `node dist/.../main.js` | Starts normally via `startStandalone()` — binds to a port |
+| **Development** | `nx serve` | Devserver sets `DEVSERVER_MODE=1`, loads the bundle, and calls `global.createChildApp()` — the app bootstraps without binding to a port |
+
+### Required Type
+
+```typescript
+export type BuiltChildApp = {
+  handler: http.RequestListener;             // Raw HTTP request handler (Fastify/Express)
+  serviceConfig: { port: number | string };  // Service configuration
+  close: () => Promise<void>;                // Cleanup function for graceful shutdown
+};
+```
+
+### Entry Point Template
+
+```typescript
+// src/deployments/service/main.ts
+import '../tracing/service'; // must be first for APM instrumentation
+import { createAppModule } from './app.module';
+import {
+  createStandaloneFunction,
+  createChildAppFunction,
+  bootstrapDevServerIfNeeded,
+} from '../bootstrap';
+
+const appModule = createAppModule();
+const startStandalone = createStandaloneFunction(appModule);
+const createChildApp = createChildAppFunction(appModule);
+bootstrapDevServerIfNeeded(startStandalone, createChildApp);
+```
+
+### Bootstrap Implementation
+
+```typescript
+// src/deployments/bootstrap.ts
+import { NestFactory } from '@nestjs/core';
+import {
+  FastifyAdapter,
+  NestFastifyApplication,
+} from '@nestjs/platform-fastify';
+import * as http from 'node:http';
+
+export function createStandaloneFunction(appModule: any) {
+  return async () => {
+    const app = await NestFactory.create<NestFastifyApplication>(
+      appModule,
+      new FastifyAdapter(),
+    );
+    await app.listen(process.env.PORT || 3000, '0.0.0.0');
+  };
+}
+
+export function createChildAppFunction(appModule: any) {
+  return async (): Promise<BuiltChildApp> => {
+    const app = await NestFactory.create<NestFastifyApplication>(
+      appModule,
+      new FastifyAdapter(),
+    );
+    await app.init();
+    await app.getHttpAdapter().getInstance().ready();
+
+    return {
+      handler: app.getHttpServer() as http.RequestListener,
+      serviceConfig: { port: process.env.PORT || 3000 },
+      close: () => app.close(),
+    };
+  };
+}
+
+export function bootstrapDevServerIfNeeded(
+  startStandalone: () => Promise<void>,
+  createChildApp: () => Promise<BuiltChildApp>,
+) {
+  if (process.env.DEVSERVER_MODE === '1') {
+    // Devserver mode: export factory for the devserver to call
+    (global as any).createChildApp = createChildApp;
+  } else {
+    // Standalone mode: start the app normally
+    startStandalone();
+  }
+}
+```
+
+## Externals Configuration
+
+By default, all `node_modules` are externalized (not bundled) except:
+- Packages matching `orgScopes` (monorepo org scopes)
+- Workspace paths (`apps/`, `libs/`)
+
+Use `bundlePackages` and `nodeExternalsConfig` for fine-grained control over what gets bundled vs. externalized.
+
+### `bundlePackages`
+
+Force-bundle specific npm packages into the output:
+
+```json
+{
+  "options": {
+    "orgScopes": ["@myorg"],
+    "bundlePackages": ["lodash", "date-fns"]
+  }
+}
+```
+
+### `nodeExternalsConfig`
+
+Override [webpack-node-externals](https://github.com/liady/webpack-node-externals) options:
+
+```json
+{
+  "options": {
+    "nodeExternalsConfig": {
+      "allowlist": ["some-esm-only-pkg"],
+      "additionalModuleDirs": ["../../shared-modules"],
+      "importType": "module"
+    }
+  }
+}
+```
+
+The `allowlist` entries are **appended** to the auto-generated patterns from `orgScopes` and `bundlePackages`.
+
+## Webpack Overrides
+
+For advanced customization (custom plugins, loaders, output tweaks), point `webpackConfigPath` to a JS file that exports a transform function:
+
+```json
+{
+  "options": {
+    "webpackConfigPath": "./webpack.overrides.js"
+  }
+}
+```
+
+```js
+// webpack.overrides.js
+const { BannerPlugin } = require('webpack');
+
+module.exports = (config) => {
+  // Add a custom plugin
+  config.plugins.push(new BannerPlugin({ banner: '/* custom banner */' }));
+
+  // Modify output settings
+  config.output.library = { type: 'commonjs2' };
+
+  return config;
+};
+```
+
+The override function receives the fully-built webpack config and must return the modified config. For the build executor, it is called on each config in the array (main build + ORM config if present).
+
+## Programmatic API
+
+The webpack config generators can be used directly for custom build setups:
+
+```typescript
+import { createProdWebpackConfig, createDevWebpackConfig } from '@davnx/webpack';
+
+// Production config
+const prodConfigs = createProdWebpackConfig({
+  appName: 'my-app',
+  appRoot: '/path/to/app',
+  outputDir: '/path/to/dist',
+  main: './src/main.ts',
+  tsConfig: './tsconfig.app.json',
+  workspaceRoot: '/path/to/workspace',
+  orgScopes: ['@myorg'],
+});
+
+// Development config
+const devConfig = createDevWebpackConfig({
+  appName: 'my-app',
+  appRoot: '/path/to/app',
+  outputDir: '/path/to/dist',
+  main: './src/main.ts',
+  tsConfig: './tsconfig.app.json',
+  workspaceRoot: '/path/to/workspace',
+  port: 3050,
+  serviceName: 'my-app',
+  orgScopes: ['@myorg'],
+});
+```
+
+### `createProdWebpackConfig(options)`
+
+Returns an array of webpack configurations. The first config is always the main application build. If an `ormconfig.ts` is detected, a second config for TypeORM migrations is included.
+
+### `createDevWebpackConfig(options)`
+
+Returns a single webpack configuration with watch mode enabled, HMR, async type checking, filesystem caching, and the `DevServerReloadPlugin` that notifies the devserver after each successful build.
+
+## Key Features
+
+- **Node 22 target** — compiled with `target: node22` for modern JavaScript
+- **Org scope bundling** — packages matching `orgScopes` are bundled into the output instead of being externalized, useful for monorepo packages
+- **Async type checking** — `fork-ts-checker-webpack-plugin` runs type checking in a separate process so builds aren't blocked
+- **Filesystem caching** — webpack cache persists across dev rebuilds for fast incremental compilation
+- **Auto package.json** — production builds generate a `package.json` with only the runtime dependencies needed
+- **Source maps** — inline source maps in production, eval source maps in development
+- **Multi-child devserver** — scale development with multiple child processes for parallel request handling
+
+## License
+
+MIT

package/create-webpack-dev.d.ts

@@ -0,0 +1,24 @@
+export interface NodeExternalsConfig {
+    allowlist?: (string | RegExp)[];
+    additionalModuleDirs?: string[];
+    importType?: string;
+}
+export interface DevWebpackOptions {
+    appName: string;
+    appRoot: string;
+    outputDir: string;
+    main: string;
+    tsConfig: string;
+    workspaceRoot: string;
+    assets?: string[];
+    port: number;
+    serviceName: string;
+    memoryLimit?: number;
+    buildLibsFromSource?: boolean;
+    orgScopes?: string[];
+    bundlePackages?: string[];
+    nodeExternalsConfig?: NodeExternalsConfig;
+    webpackConfigPath?: string;
+}
+export declare function createDevWebpackConfig(options: DevWebpackOptions): Record<string, any>;
+//# sourceMappingURL=create-webpack-dev.d.ts.map

package/create-webpack-dev.js

@@ -0,0 +1,155 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDevWebpackConfig = createDevWebpackConfig;
+const app_plugin_1 = require("@nx/webpack/app-plugin");
+const path = __importStar(require("node:path"));
+const nodeExternals = __importStar(require("webpack-node-externals"));
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const webpack = require('webpack');
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const ForkTsCheckerWebpackPlugin = require('fork-ts-checker-webpack-plugin');
+class DevServerReloadPlugin {
+    url;
+    constructor(port) {
+        this.url = `http://localhost:${port}/webpack/reload`;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    apply(compiler) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        compiler.hooks.done.tap('DevServerReloadPlugin', async (stats) => {
+            try {
+                if (stats.hasErrors())
+                    return;
+                await fetch(this.url, { method: 'POST', headers: { 'content-type': 'application/json' }, body: '{}' });
+                console.log('[DevServerReloadPlugin] notified devserver to reload');
+            }
+            catch {
+                console.log('[DevServerReloadPlugin] devserver not running yet');
+            }
+        });
+    }
+}
+function buildScopePatterns(orgScopes) {
+    const allowlistPatterns = orgScopes.map((scope) => new RegExp(`^${scope.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}/`));
+    const scopePrefixes = orgScopes.map((scope) => (scope.endsWith('/') ? scope : `${scope}/`));
+    return { allowlistPatterns, scopePrefixes };
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function createDevWebpackConfig(options) {
+    const { appRoot, outputDir, main, tsConfig, workspaceRoot, assets = [], port, memoryLimit = 8192, buildLibsFromSource = true, orgScopes = [], bundlePackages = [], nodeExternalsConfig: userNodeExternalsConfig, webpackConfigPath, } = options;
+    const { allowlistPatterns, scopePrefixes } = buildScopePatterns(orgScopes);
+    // Build combined allowlist: orgScopes + bundlePackages + user-provided
+    const bundlePatterns = bundlePackages.map((pkg) => new RegExp(`^${pkg.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(/|$)`));
+    const combinedAllowlist = [
+        /webpack\/hot\/poll\?100/,
+        ...allowlistPatterns,
+        ...bundlePatterns,
+        ...(userNodeExternalsConfig?.allowlist || []),
+    ];
+    const config = {
+        output: {
+            path: outputDir,
+            ...(process.env.NODE_ENV !== 'production' && {
+                devtoolModuleFilenameTemplate: '[absolute-resource-path]',
+            }),
+            clean: true,
+        },
+        externals: [
+            nodeExternals({
+                allowlist: combinedAllowlist,
+                additionalModuleDirs: userNodeExternalsConfig?.additionalModuleDirs || [],
+                ...(userNodeExternalsConfig?.importType && { importType: userNodeExternalsConfig.importType }),
+            }),
+            ({ request }, callback) => {
+                if (request &&
+                    (request.startsWith(path.join(workspaceRoot, 'apps')) ||
+                        request.startsWith(path.join(workspaceRoot, 'libs')))) {
+                    return callback();
+                }
+                if (request && scopePrefixes.some((prefix) => request.startsWith(prefix))) {
+                    return callback();
+                }
+                if (request && !(request.startsWith('./') || request.startsWith('..'))) {
+                    return callback(null, `commonjs ${request}`);
+                }
+                return callback();
+            },
+        ],
+        mode: 'development',
+        devtool: 'eval-cheap-module-source-map',
+        plugins: [
+            new webpack.HotModuleReplacementPlugin(),
+            new app_plugin_1.NxAppWebpackPlugin({
+                target: 'node22',
+                compiler: 'tsc',
+                main,
+                additionalEntryPoints: [],
+                verbose: true,
+                sourceMap: 'eval-cheap-module-source-map',
+                mergeExternals: true,
+                externalDependencies: [],
+                memoryLimit,
+                tsConfig,
+                assets,
+                optimization: false,
+                progress: false,
+                outputHashing: 'none',
+                generatePackageJson: false,
+                watchDependencies: true,
+                typeCheckOptions: {
+                    async: true,
+                },
+                buildLibsFromSource,
+            }),
+            new DevServerReloadPlugin(port),
+        ],
+        snapshot: { managedPaths: [/^(.+?[\\/])?node_modules[\\/]/] },
+        watch: true,
+        watchOptions: {
+            ignored: ['**/*.env.template', '**/config.template.json', '**/*.md', '**/dist/**', '**/migrations/**'],
+        },
+        cache: { type: 'filesystem' },
+    };
+    // Apply user webpack overrides if configured
+    if (webpackConfigPath) {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const overrideModule = require(path.resolve(appRoot, webpackConfigPath));
+        const overrideFn = overrideModule.default || overrideModule;
+        return overrideFn(config);
+    }
+    return config;
+}
+//# sourceMappingURL=create-webpack-dev.js.map

package/create-webpack-dev.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-webpack-dev.js","sourceRoot":"","sources":["../../../libs/webpack/src/create-webpack-dev.ts"],"names":[],"mappings":"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"}

package/create-webpack-prod.d.ts

@@ -0,0 +1,32 @@
+type Configuration = Record<string, any>;
+export interface NodeExternalsConfig {
+    allowlist?: (string | RegExp)[];
+    additionalModuleDirs?: string[];
+    importType?: string;
+}
+export interface ProdWebpackOptions {
+    appName: string;
+    appRoot: string;
+    outputDir: string;
+    main: string;
+    tsConfig: string;
+    workspaceRoot: string;
+    assets?: string[];
+    additionalEntryPoints?: Array<{
+        entryName: string;
+        entryPath: string;
+    }>;
+    runtimeDependencies?: string[];
+    memoryLimit?: number;
+    generatePackageJson?: boolean;
+    buildLibsFromSource?: boolean;
+    ormConfigPath?: string;
+    migrationsDir?: string;
+    orgScopes?: string[];
+    bundlePackages?: string[];
+    nodeExternalsConfig?: NodeExternalsConfig;
+    webpackConfigPath?: string;
+}
+export declare function createProdWebpackConfig(options: ProdWebpackOptions): Configuration[];
+export {};
+//# sourceMappingURL=create-webpack-prod.d.ts.map