@nx/webpack 0.0.0-pr-22179-271588f

package/src/executors/ssr-dev-server/lib/wait-until-server-is-listening.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitUntilServerIsListening = void 0;
+const net = require("net");
+function waitUntilServerIsListening(port) {
+    const allowedErrorCodes = ['ECONNREFUSED', 'ECONNRESET'];
+    const maxAttempts = 25;
+    let attempts = 0;
+    const client = new net.Socket();
+    const cleanup = () => {
+        client.removeAllListeners('connect');
+        client.removeAllListeners('error');
+        client.end();
+        client.destroy();
+        client.unref();
+    };
+    return new Promise((resolve, reject) => {
+        const listen = () => {
+            client.once('connect', () => {
+                cleanup();
+                resolve();
+            });
+            client.on('error', (err) => {
+                if (attempts > maxAttempts ||
+                    !allowedErrorCodes.includes(err['code'])) {
+                    cleanup();
+                    reject(err);
+                }
+                else {
+                    attempts++;
+                    setTimeout(listen, 100 * attempts);
+                }
+            });
+            client.connect({ port, host: 'localhost' });
+        };
+        listen();
+    });
+}
+exports.waitUntilServerIsListening = waitUntilServerIsListening;

package/src/executors/ssr-dev-server/schema.d.ts

@@ -0,0 +1,11 @@
+interface TargetOptions {
+  [key: string]: string | boolean | number | TargetOptions;
+}
+
+export interface WebSsrDevServerOptions {
+  browserTarget: string;
+  serverTarget: string;
+  port: number;
+  browserTargetOptions: TargetOptions;
+  serverTargetOptions: TargetOptions;
+}

package/src/executors/ssr-dev-server/schema.json

@@ -0,0 +1,37 @@
+{
+  "version": 2,
+  "outputCapture": "direct-nodejs",
+  "title": "Webpack SSR Dev Server",
+  "description": "Serve a SSR application using webpack.",
+  "cli": "nx",
+  "type": "object",
+  "properties": {
+    "browserTarget": {
+      "type": "string",
+      "description": "Target which builds the browser application.",
+      "x-priority": "important"
+    },
+    "serverTarget": {
+      "type": "string",
+      "description": "Target which builds the server application.",
+      "x-priority": "important"
+    },
+    "port": {
+      "type": "number",
+      "description": "The port to be set on `process.env.PORT` for use in the server.",
+      "default": 4200,
+      "x-priority": "important"
+    },
+    "browserTargetOptions": {
+      "type": "object",
+      "description": "Additional options to pass into the browser build target.",
+      "default": {}
+    },
+    "serverTargetOptions": {
+      "type": "object",
+      "description": "Additional options to pass into the server build target.",
+      "default": {}
+    }
+  },
+  "required": ["browserTarget", "serverTarget"]
+}

package/src/executors/ssr-dev-server/ssr-dev-server.impl.d.ts

@@ -0,0 +1,8 @@
+import { ExecutorContext } from '@nx/devkit';
+import { TargetOptions, WebSsrDevServerOptions } from './schema';
+export declare function ssrDevServerExecutor(options: WebSsrDevServerOptions, context: ExecutorContext): AsyncGenerator<{
+    baseUrl: string;
+    success: boolean;
+    options: TargetOptions;
+}, void, unknown>;
+export default ssrDevServerExecutor;

package/src/executors/ssr-dev-server/ssr-dev-server.impl.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ssrDevServerExecutor = void 0;
+const devkit_1 = require("@nx/devkit");
+const chalk = require("chalk");
+const async_iterable_1 = require("@nx/devkit/src/utils/async-iterable");
+const wait_until_server_is_listening_1 = require("./lib/wait-until-server-is-listening");
+async function* ssrDevServerExecutor(options, context) {
+    const browserTarget = (0, devkit_1.parseTargetString)(options.browserTarget, context.projectGraph);
+    const serverTarget = (0, devkit_1.parseTargetString)(options.serverTarget, context);
+    const browserOptions = (0, devkit_1.readTargetOptions)(browserTarget, context);
+    const serverOptions = (0, devkit_1.readTargetOptions)(serverTarget, context);
+    const runBrowser = await (0, devkit_1.runExecutor)(browserTarget, { ...browserOptions, ...options.browserTargetOptions }, context);
+    const runServer = await (0, devkit_1.runExecutor)(serverTarget, { ...serverOptions, ...options.serverTargetOptions }, context);
+    let browserBuilt = false;
+    let nodeStarted = false;
+    const combined = (0, async_iterable_1.combineAsyncIterables)(runBrowser, runServer);
+    process.env['PORT'] = `${options.port}`;
+    for await (const output of combined) {
+        if (!output.success)
+            throw new Error('Could not build application');
+        if (output.options?.target === 'node') {
+            nodeStarted = true;
+        }
+        else if (output.options?.target === 'web') {
+            browserBuilt = true;
+        }
+        if (nodeStarted && browserBuilt) {
+            await (0, wait_until_server_is_listening_1.waitUntilServerIsListening)(options.port);
+            console.log(`[ ${chalk.green('ready')} ] on http://localhost:${options.port}`);
+            yield {
+                ...output,
+                baseUrl: `http://localhost:${options.port}`,
+            };
+        }
+    }
+}
+exports.ssrDevServerExecutor = ssrDevServerExecutor;
+exports.default = ssrDevServerExecutor;

package/src/executors/webpack/lib/normalize-options.d.ts

@@ -0,0 +1,3 @@
+import type { NormalizedWebpackExecutorOptions, WebpackExecutorOptions } from '../schema';
+export declare function normalizeOptions(options: WebpackExecutorOptions, root: string, projectRoot: string, sourceRoot: string): NormalizedWebpackExecutorOptions;
+export declare function normalizePluginPath(pluginPath: void | string, root: string): string;

package/src/executors/webpack/lib/normalize-options.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizePluginPath = exports.normalizeOptions = void 0;
+const path_1 = require("path");
+const normalize_options_1 = require("../../../plugins/nx-webpack-plugin/lib/normalize-options");
+function normalizeOptions(options, root, projectRoot, sourceRoot) {
+    const normalizedOptions = {
+        ...options,
+        root,
+        projectRoot,
+        sourceRoot,
+        target: options.target ?? 'web',
+        outputFileName: options.outputFileName ?? 'main.js',
+        webpackConfig: normalizePluginPath(options.webpackConfig, root),
+        fileReplacements: (0, normalize_options_1.normalizeFileReplacements)(root, options.fileReplacements),
+        optimization: typeof options.optimization !== 'object'
+            ? {
+                scripts: options.optimization,
+                styles: options.optimization,
+            }
+            : options.optimization,
+    };
+    if (options.assets) {
+        normalizedOptions.assets = (0, normalize_options_1.normalizeAssets)(options.assets, root, sourceRoot, projectRoot);
+    }
+    return normalizedOptions;
+}
+exports.normalizeOptions = normalizeOptions;
+function normalizePluginPath(pluginPath, root) {
+    if (!pluginPath) {
+        return '';
+    }
+    try {
+        return require.resolve(pluginPath);
+    }
+    catch {
+        return (0, path_1.resolve)(root, pluginPath);
+    }
+}
+exports.normalizePluginPath = normalizePluginPath;

package/src/executors/webpack/lib/run-webpack.d.ts

@@ -0,0 +1,3 @@
+import * as webpack from 'webpack';
+import { Observable } from 'rxjs';
+export declare function runWebpack(config: webpack.Configuration): Observable<webpack.Stats>;

package/src/executors/webpack/lib/run-webpack.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runWebpack = void 0;
+const webpack = require("webpack");
+const rxjs_1 = require("rxjs");
+// TODO(jack): move to dev-server executor
+function runWebpack(config) {
+    return new rxjs_1.Observable((subscriber) => {
+        // Passing `watch` option here will result in a warning due to missing callback.
+        // We manually call `.watch` or `.run` later so this option isn't needed here.
+        const { watch, ...normalizedConfig } = config;
+        const webpackCompiler = webpack(normalizedConfig);
+        const callback = (err, stats) => {
+            if (err) {
+                subscriber.error(err);
+            }
+            subscriber.next(stats);
+        };
+        if (config.watch) {
+            const watchOptions = config.watchOptions || {};
+            const watching = webpackCompiler.watch(watchOptions, callback);
+            return () => watching.close(() => subscriber.complete());
+        }
+        else {
+            webpackCompiler.run((err, stats) => {
+                callback(err, stats);
+                webpackCompiler.close((closeErr) => {
+                    if (closeErr)
+                        subscriber.error(closeErr);
+                    subscriber.complete();
+                });
+            });
+        }
+    });
+}
+exports.runWebpack = runWebpack;

package/src/executors/webpack/schema.d.ts

@@ -0,0 +1,96 @@
+import { AssetGlob } from '@nx/js/src/utils/assets/assets';
+
+export interface AssetGlobPattern {
+  glob: string;
+  input: string;
+  output: string;
+  ignore?: string[];
+}
+
+export interface ExtraEntryPointClass {
+  bundleName?: string;
+  inject?: boolean;
+  input: string;
+  lazy?: boolean;
+}
+
+export interface FileReplacement {
+  replace: string;
+  with: string;
+}
+
+export interface AdditionalEntryPoint {
+  entryName: string;
+  entryPath: string;
+}
+
+export interface TransformerPlugin {
+  name: string;
+  options: Record<string, unknown>;
+}
+
+export type TransformerEntry = string | TransformerPlugin;
+
+export interface OptimizationOptions {
+  scripts: boolean;
+  styles: boolean;
+}
+
+export interface WebpackExecutorOptions {
+  additionalEntryPoints?: AdditionalEntryPoint[];
+  assets?: Array<AssetGlob | string>;
+  buildLibsFromSource?: boolean;
+  commonChunk?: boolean;
+  compiler?: 'babel' | 'swc' | 'tsc';
+  deleteOutputPath?: boolean;
+  externalDependencies?: 'all' | 'none' | string[];
+  extractLicenses?: boolean;
+  fileReplacements?: FileReplacement[];
+  generatePackageJson?: boolean;
+  // TODO(v19): Remove this option
+  /** @deprecated set webpackConfig and provide an explicit webpack.config.js file (See: https://nx.dev/recipes/webpack/webpack-config-setup) */
+  isolatedConfig?: boolean;
+  standardWebpackConfigFunction?: boolean;
+  main?: string;
+  memoryLimit?: number;
+  namedChunks?: boolean;
+  optimization?: boolean | OptimizationOptions;
+  outputFileName?: string;
+  outputHashing?: any;
+  outputPath: string;
+  poll?: number;
+  polyfills?: string;
+  progress?: boolean;
+  runtimeChunk?: boolean;
+  sourceMap?: boolean | 'hidden';
+  statsJson?: boolean;
+  target?: string;
+  transformers?: TransformerEntry[];
+  tsConfig?: string;
+  vendorChunk?: boolean;
+  verbose?: boolean;
+  watch?: boolean;
+  webpackConfig?: string;
+  babelConfig?: string;
+  babelUpwardRootMode?: boolean;
+  baseHref?: string;
+  crossOrigin?: 'none' | 'anonymous' | 'use-credentials';
+  deployUrl?: string;
+  extractCss?: boolean;
+  generateIndexHtml?: boolean;
+  index?: string;
+  postcssConfig?: string;
+  scripts?: Array<ExtraEntryPointClass | string>;
+  stylePreprocessorOptions?: any;
+  styles?: Array<ExtraEntryPointClass | string>;
+  subresourceIntegrity?: boolean;
+}
+
+export interface NormalizedWebpackExecutorOptions
+  extends WebpackExecutorOptions {
+  outputFileName: string;
+  assets: AssetGlobPattern[];
+  root: string;
+  projectRoot: string;
+  sourceRoot: string;
+}