cyberia 2.8.885

package/src/runtime/express/Express.js

@@ -0,0 +1,256 @@
+/**
+ * A service dedicated to creating and configuring an Express.js application
+ * instance based on server configuration data.
+ * @module src/runtime/express/Express.js
+ * @namespace ExpressService
+ */
+
+import fs from 'fs-extra';
+import express from 'express';
+import fileUpload from 'express-fileupload';
+import swaggerUi from 'swagger-ui-express';
+import compression from 'compression';
+import { createServer } from 'http';
+
+import UnderpostStartUp from '../../server/start.js';
+import { loggerFactory, loggerMiddleware } from '../../server/logger.js';
+import { getCapVariableName, newInstance } from '../../client/components/core/CommonJs.js';
+import { MailerProvider } from '../../mailer/MailerProvider.js';
+import { DataBaseProvider } from '../../db/DataBaseProvider.js';
+import { createPeerServer } from '../../server/peer.js';
+import { createValkeyConnection } from '../../server/valkey.js';
+import { applySecurity, authMiddlewareFactory } from '../../server/auth.js';
+import { ssrMiddlewareFactory } from '../../server/ssr.js';
+import { TLS } from '../../server/tls.js';
+import { shellExec } from '../../server/process.js';
+
+const logger = loggerFactory(import.meta);
+
+/**
+ * @class ExpressService
+ * @description A service dedicated to creating and configuring an Express.js application
+ * instance based on server configuration data.
+ * @memberof ExpressService
+ */
+class ExpressService {
+  /**
+   * Creates and configures a complete Express application instance for a specific host/path configuration.
+   *
+   * @method createApp
+   * @memberof ExpressService
+   * @param {string} config.host - The host name for the instance (e.g., 'www.example.com').
+   * @param {string} config.path - The URL path for the instance (e.g., '/', '/api/v1').
+   * @param {number} config.port - The primary listening port for the instance.
+   * @param {string} config.client - The client associated with the instance (used for SSR/Mailer configuration lookup).
+   * @param {string[]} [config.apis] - A list of API names to load and attach routers for.
+   * @param {string[]} config.origins - Allowed origins for CORS.
+   * @param {string} [config.directory] - The directory for static files (if overriding default).
+   * @param {boolean} [config.useLocalSsl] - Whether to use local SSL for the instance.
+   * @param {string} [config.ws] - The WebSocket server name to use.
+   * @param {object} [config.mailer] - Mailer configuration.
+   * @param {object} [config.db] - Database configuration.
+   * @param {string} [config.redirect] - URL or flag to indicate an HTTP redirect should be configured.
+   * @param {boolean} [config.peer] - Whether to enable the peer server.
+   * @param {object} [config.valkey] - Valkey connection configuration.
+   * @param {string} [config.apiBaseHost] - Base host for the API (if running separate API).
+   * @param {string} config.redirectTarget - The full target URL for redirection (used if `redirect` is true).
+   * @param {string} config.rootHostPath - The root path for public host assets (e.g., `/public/hostname`).
+   * @param {object} config.confSSR - The SSR configuration object, used to look up Mailer templates.
+   * @param {import('prom-client').Counter<string>} config.promRequestCounter - Prometheus request counter instance.
+   * @param {import('prom-client').Registry} config.promRegister - Prometheus register instance for metrics.
+   * @returns {Promise<{portsUsed: number}>} An object indicating how many additional ports were used (e.g., for PeerServer).
+   */
+  async createApp({
+    host,
+    path,
+    port,
+    client,
+    apis,
+    origins,
+    directory,
+    useLocalSsl,
+    ws,
+    mailer,
+    db,
+    redirect,
+    peer,
+    valkey,
+    apiBaseHost,
+    redirectTarget,
+    rootHostPath,
+    confSSR,
+    promRequestCounter,
+    promRegister,
+  }) {
+    let portsUsed = 0;
+    const runningData = {
+      host,
+      path,
+      runtime: 'nodejs',
+      client,
+      meta: import.meta,
+      apis,
+    };
+
+    const app = express();
+
+    if (process.env.NODE_ENV === 'production') app.set('trust proxy', true);
+
+    app.use((req, res, next) => {
+      res.on('finish', () => {
+        promRequestCounter.inc({
+          instance: `${host}:${port}${path}`,
+          method: req.method,
+          status_code: res.statusCode,
+        });
+      });
+      return next();
+    });
+
+    // Metrics endpoint
+    app.get(`${path === '/' ? '' : path}/metrics`, async (req, res) => {
+      res.set('Content-Type', promRegister.contentType);
+      return res.end(await promRegister.metrics());
+    });
+
+    // Logging, Compression, and Body Parsers
+    app.use(loggerMiddleware(import.meta));
+    app.use(compression({ filter: (req, res) => !req.headers['x-no-compression'] && compression.filter(req, res) }));
+    app.use(express.json({ limit: '100MB' }));
+    app.use(express.urlencoded({ extended: true, limit: '20MB' }));
+    app.use(fileUpload());
+
+    if (process.env.NODE_ENV === 'development') app.set('json spaces', 2);
+
+    // Language handling middleware
+    app.use((req, res, next) => {
+      const lang = req.headers['accept-language'] || 'en';
+      req.lang = typeof lang === 'string' && lang.toLowerCase().match('es') ? 'es' : 'en';
+      return next();
+    });
+
+    // Static file serving
+    app.use('/', express.static(directory ? directory : `.${rootHostPath}`));
+
+    // Handle redirection-only instances
+    if (redirect) {
+      app.use((req, res, next) => {
+        if (process.env.NODE_ENV === 'production' && !req.url.startsWith(`/.well-known/acme-challenge`)) {
+          return res.status(302).redirect(redirectTarget + req.url);
+        }
+        return next();
+      });
+      await UnderpostStartUp.API.listenPortController(app, port, runningData);
+      return { portsUsed };
+    }
+
+    // Create HTTP server for regular instances (required for WebSockets)
+    const server = createServer({}, app);
+
+    if (!apiBaseHost) {
+      // Swagger path definition
+      const swaggerJsonPath = `./public/${host}${path === '/' ? path : `${path}/`}swagger-output.json`;
+      const swaggerPath = `${path === '/' ? `/api-docs` : `${path}/api-docs`}`;
+
+      // Flag swagger requests before security middleware
+      if (fs.existsSync(swaggerJsonPath)) {
+        app.use(swaggerPath, (req, res, next) => {
+          res.locals.isSwagger = true;
+          next();
+        });
+      }
+
+      // Swagger UI setup
+      if (fs.existsSync(swaggerJsonPath)) {
+        const swaggerDoc = JSON.parse(fs.readFileSync(swaggerJsonPath, 'utf8'));
+        // Reusing swaggerPath defined outside, removing unnecessary redeclaration
+        app.use(swaggerPath, swaggerUi.serve, swaggerUi.setup(swaggerDoc));
+      }
+
+      // Security and CORS
+      if (process.env.NODE_ENV === 'development' && useLocalSsl)
+        origins = origins.map((origin) => origin.replace('http', 'https'));
+
+      applySecurity(app, {
+        origin: origins,
+      });
+
+      // Database and Valkey connections
+      if (db && apis) await DataBaseProvider.load({ apis, host, path, db });
+      if (valkey) await createValkeyConnection({ host, path }, valkey);
+
+      // Mailer setup
+      if (mailer) {
+        const mailerSsrConf = confSSR[getCapVariableName(client)];
+        await MailerProvider.load({
+          id: `${host}${path}`,
+          meta: `mailer-${host}${path}`,
+          host,
+          path,
+          ...mailer,
+          templates: mailerSsrConf ? mailerSsrConf.mailer : {},
+        });
+      }
+
+      // API router loading
+      if (apis && apis.length > 0) {
+        const authMiddleware = authMiddlewareFactory({ host, path });
+        const apiPath = `${path === '/' ? '' : path}/${process.env.BASE_API}`;
+        for (const api of apis) {
+          logger.info(`Build api server`, `${host}${apiPath}/${api}`);
+          const { ApiRouter } = await import(`../../api/${api}/${api}.router.js`);
+          const router = ApiRouter({ host, path, apiPath, mailer, db, authMiddleware, origins });
+          app.use(`${apiPath}/${api}`, router);
+        }
+      }
+
+      // WebSocket server setup
+      if (ws) {
+        const { createIoServer } = await import(`../../ws/${ws}/${ws}.ws.server.js`);
+        const { options, meta, ioServer } = await createIoServer(server, { host, path, db, port, origins });
+
+        // Listen on the main port for the WS server
+        await UnderpostStartUp.API.listenPortController(ioServer, port, {
+          runtime: 'nodejs',
+          client: null,
+          host,
+          path: options.path,
+          meta,
+        });
+      }
+
+      // Peer server setup
+      if (peer) {
+        portsUsed++; // Peer server uses one additional port
+        const peerPort = newInstance(port + portsUsed); // portsUsed is 1 here
+        const { options, meta, peerServer } = await createPeerServer({
+          port: peerPort,
+          origins,
+          path,
+        });
+        await UnderpostStartUp.API.listenPortController(peerServer, peerPort, {
+          runtime: 'nodejs',
+          client: null,
+          host,
+          path: options.path,
+          meta,
+        });
+      }
+    }
+
+    // SSR middleware loading
+    const ssr = await ssrMiddlewareFactory({ app, directory, rootHostPath, path });
+    for (const [_, ssrMiddleware] of Object.entries(ssr)) app.use(ssrMiddleware);
+
+    // Start listening on the main port
+    if (useLocalSsl && process.env.NODE_ENV === 'development') {
+      if (!TLS.validateSecureContext()) shellExec(`node bin/deploy tls`);
+      const { ServerSSL } = await TLS.createSslServer(app);
+      await UnderpostStartUp.API.listenPortController(ServerSSL, port, runningData);
+    } else await UnderpostStartUp.API.listenPortController(server, port, runningData);
+
+    return { portsUsed };
+  }
+}
+
+export default new ExpressService();

package/src/runtime/lampp/Dockerfile

@@ -0,0 +1,50 @@
+FROM rockylinux:9
+
+# --- Update and install required packages
+RUN dnf -y update && \
+    dnf -y install epel-release && \
+    dnf -y install --allowerasing \
+        bzip2 \
+        sudo \
+        curl \
+        net-tools \
+        openssh-server \
+        nano \
+        vim-enhanced \
+        less \
+        openssl-devel \
+        wget \
+        git \
+        gnupg2 \
+        libnsl \
+        perl && \
+    dnf clean all
+
+# --- Download and install XAMPP
+RUN curl -L -o /tmp/xampp-linux-installer.run "https://sourceforge.net/projects/xampp/files/XAMPP%20Linux/7.4.33/xampp-linux-x64-7.4.33-0-installer.run" && \
+    chmod +x /tmp/xampp-linux-installer.run && \
+    bash -c "/tmp/xampp-linux-installer.run --mode unattended" && \
+    ln -sf /opt/lampp/lampp /usr/bin/lampp
+
+# --- Create /xampp/htdocs (static root) and set permissions
+RUN mkdir -p /opt/lampp/htdocs && \
+    chown -R root:root /opt/lampp/htdocs && \
+    chmod -R a+rX /opt/lampp/htdocs
+
+# Install Node.js
+RUN curl -fsSL https://rpm.nodesource.com/setup_24.x | bash -
+RUN dnf install nodejs -y
+RUN dnf clean all
+
+# Verify Node.js and npm versions
+RUN node --version
+RUN npm --version
+
+# Set working directory
+WORKDIR /home/dd
+
+EXPOSE 22
+EXPOSE 80
+EXPOSE 443
+EXPOSE 3000-3100
+EXPOSE 4000-4100

package/src/runtime/lampp/Lampp.js

@@ -0,0 +1,343 @@
+/**
+ * Exported singleton instance of the LamppService class.
+ * This object is used to interact with the Lampp configuration and service.
+ * @module src/runtime/lampp/Lampp.js
+ * @namespace LamppService
+ */
+
+import fs from 'fs-extra';
+import { getRootDirectory, shellCd, shellExec } from '../../server/process.js';
+import { loggerFactory } from '../../server/logger.js';
+
+const logger = loggerFactory(import.meta);
+
+/**
+ * @class LamppService
+ * @description Provides utilities for managing the XAMPP (Lampp) service on Linux,
+ * including initialization, router configuration, and virtual host creation.
+ * It manages the server's configuration files and controls the service process.
+ * @memberof LamppService
+ */
+class LamppService {
+  /**
+   * @private
+   * @type {string | undefined}
+   * @description Stores the accumulated Apache virtual host configuration (router definition).
+   * @memberof LamppService
+   */
+  router;
+
+  /**
+   * @public
+   * @type {number[]}
+   * @description A list of ports currently configured and listened to by the Lampp service.
+   * @memberof LamppService
+   */
+  ports;
+
+  /**
+   * Creates an instance of LamppService.
+   * Initializes the router configuration and ports list.
+   * @method constructor
+   * @memberof LamppService
+   */
+  constructor() {
+    this.router = undefined;
+    this.ports = [];
+  }
+
+  /**
+   * Checks if the XAMPP (Lampp) service appears to be installed based on the presence of its main configuration file.
+   *
+   * @method enabled
+   * @memberof LamppService
+   * @returns {boolean} True if the configuration file exists, indicating Lampp is likely installed.
+   * @throws {Error} If the configuration file does not exist.
+   * @memberof LamppService
+   */
+  enabled() {
+    return fs.existsSync('/opt/lampp/etc/httpd.conf');
+  }
+
+  /**
+   * Initializes or restarts the Lampp Apache service.
+   * This method configures virtual hosts, disables default ports (80/443) in the main config
+   * to avoid conflicts, and starts or stops the service using shell commands.
+   *
+   * @method initService
+   * @param {object} [options={daemon: false}] - Options for service initialization.
+   * @param {boolean} [options.daemon=false] - Flag to indicate if the service should be run as a daemon (currently unused in logic).
+   * @returns {Promise<void>}
+   * @memberof LamppService
+   */
+  async initService(options = { daemon: false }) {
+    let cmd;
+
+    // 1. Write the current virtual host router configuration
+    fs.writeFileSync(`/opt/lampp/etc/extra/httpd-vhosts.conf`, this.router || '', 'utf8');
+
+    // 2. Ensure the vhosts file is included in the main httpd.conf
+    const httpdConfPath = `/opt/lampp/etc/httpd.conf`;
+    fs.writeFileSync(
+      httpdConfPath,
+      fs
+        .readFileSync(httpdConfPath, 'utf8')
+        .replace(`#Include etc/extra/httpd-vhosts.conf`, `Include etc/extra/httpd-vhosts.conf`),
+      'utf8',
+    );
+
+    // 3. Stop the service before making port changes
+    cmd = `sudo /opt/lampp/lampp stop`;
+    shellExec(cmd);
+
+    // 4. Comment out default port Listen directives (80 and 443) to prevent conflicts
+    // Modify httpd.conf (port 80)
+    if (!fs.readFileSync(httpdConfPath, 'utf8').match(/# Listen 80/))
+      fs.writeFileSync(
+        httpdConfPath,
+        fs.readFileSync(httpdConfPath, 'utf8').replace(`Listen 80`, `# Listen 80`),
+        'utf8',
+      );
+
+    // Modify httpd-ssl.conf (port 443)
+    const httpdSslConfPath = `/opt/lampp/etc/extra/httpd-ssl.conf`;
+    if (fs.existsSync(httpdSslConfPath) && !fs.readFileSync(httpdSslConfPath, 'utf8').match(/# Listen 443/))
+      fs.writeFileSync(
+        httpdSslConfPath,
+        fs.readFileSync(httpdSslConfPath, 'utf8').replace(`Listen 443`, `# Listen 443`),
+        'utf8',
+      );
+
+    // 5. Modify the lampp startup script to bypass port checking for 80 and 443
+    const lamppScriptPath = `/opt/lampp/lampp`;
+    if (!fs.readFileSync(lamppScriptPath, 'utf8').match(/testport 443 && false/))
+      fs.writeFileSync(
+        lamppScriptPath,
+        fs.readFileSync(lamppScriptPath, 'utf8').replace(`testport 443`, `testport 443 && false`),
+        'utf8',
+      );
+    if (!fs.readFileSync(lamppScriptPath, 'utf8').match(/testport 80 && false/))
+      fs.writeFileSync(
+        lamppScriptPath,
+        fs.readFileSync(lamppScriptPath, 'utf8').replace(`testport 80`, `testport 80 && false`),
+        'utf8',
+      );
+
+    // 6. Start the service
+    cmd = `sudo /opt/lampp/lampp start`;
+    if (this.router) fs.writeFileSync(`./tmp/lampp-router.conf`, this.router, 'utf-8');
+    shellExec(cmd);
+  }
+
+  /**
+   * Appends new Apache VirtualHost configuration content to the internal router string.
+   * If a router config file exists from a previous run, it loads it first.
+   *
+   * @method appendRouter
+   * @param {string} render - The new VirtualHost configuration string to append.
+   * @returns {string} The complete, updated router configuration string.
+   * @memberof LamppService
+   */
+  appendRouter(render) {
+    if (!this.router) {
+      if (fs.existsSync(`./tmp/lampp-router.conf`)) {
+        this.router = fs.readFileSync(`./tmp/lampp-router.conf`, 'utf-8');
+        return this.router + render;
+      }
+      return (this.router = render);
+    }
+    return (this.router += render);
+  }
+
+  /**
+   * Resets the internal router configuration and removes the temporary configuration file.
+   *
+   * @memberof LamppService
+   * @returns {void}
+   */
+  removeRouter() {
+    this.router = undefined;
+    if (fs.existsSync(`./tmp/lampp-router.conf`)) fs.rmSync(`./tmp/lampp-router.conf`);
+  }
+
+  /**
+   * Installs and configures the Lampp service on Linux.
+   * This includes downloading the installer, running it, and setting up initial configurations.
+   * Only runs on the 'linux' platform.
+   *
+   * @method install
+   * @returns {Promise<void>}
+   * @memberof LamppService
+   */
+  async install() {
+    if (process.platform === 'linux') {
+      if (!fs.existsSync(`./engine-private/setup`)) fs.mkdirSync(`./engine-private/setup`, { recursive: true });
+
+      shellCd(`./engine-private/setup`);
+
+      if (!process.argv.includes(`server`)) {
+        // Download and run the XAMPP installer
+        shellExec(
+          `curl -Lo xampp-linux-installer.run https://sourceforge.net/projects/xampp/files/XAMPP%20Linux/7.4.30/xampp-linux-x64-7.4.30-1-installer.run?from_af=true`,
+        );
+        shellExec(`sudo chmod +x xampp-linux-installer.run`);
+        shellExec(
+          `sudo ./xampp-linux-installer.run --mode unattended && \\` +
+            // Create symlink for easier access
+            `ln -sf /opt/lampp/lampp /usr/bin/lampp && \\` +
+            // Allow all access to xampp config (security measure override)
+            `sed -i.bak s'/Require local/Require all granted/g' /opt/lampp/etc/extra/httpd-xampp.conf && \\` +
+            // Enable display errors in PHP
+            `sed -i.bak s'/display_errors=Off/display_errors=On/g' /opt/lampp/etc/php.ini && \\` +
+            // Allow including custom Apache configuration files
+            `mkdir /opt/lampp/apache2/conf.d && \\` +
+            `echo "IncludeOptional /opt/lampp/apache2/conf.d/*.conf" >> /opt/lampp/etc/httpd.conf && \\` +
+            // Create /www directory and symlink it to htdocs
+            `mkdir /www && \\` +
+            `ln -s /www /opt/lampp/htdocs`,
+        );
+      }
+
+      // Copy log files to standard names for easier consumption
+      if (fs.existsSync(`/opt/lampp/logs/access_log`))
+        fs.copySync(`/opt/lampp/logs/access_log`, `/opt/lampp/logs/access.log`);
+      if (fs.existsSync(`/opt/lampp/logs/error_log`))
+        fs.copySync(`/opt/lampp/logs/error_log`, `/opt/lampp/logs/error.log`);
+      if (fs.existsSync(`/opt/lampp/logs/php_error_log`))
+        fs.copySync(`/opt/lampp/logs/php_error_log`, `/opt/lampp/logs/php_error.log`);
+      if (fs.existsSync(`/opt/lampp/logs/ssl_request_log`))
+        fs.copySync(`/opt/lampp/logs/ssl_request_log`, `/opt/lampp/logs/ssl_request.log`);
+
+      // Initialize the service after installation
+      await this.initService({ daemon: true });
+    }
+  }
+
+  /**
+   * Creates and appends a new Apache VirtualHost entry to the router configuration for a web application.
+   * The router is then applied by calling {@link LamppService#initService}.
+   *
+   * @method createApp
+   * @param {object} options - Configuration options for the new web application.
+   * @param {number} options.port - The port the VirtualHost should listen on.
+   * @param {string} options.host - The ServerName/host for the VirtualHost.
+   * @param {string} options.path - The base path for error documents (e.g., '/app').
+   * @param {string} [options.directory] - Optional absolute path to the document root.
+   * @param {string} [options.rootHostPath] - Relative path from the root directory to the document root, used if `directory` is not provided.
+   * @param {boolean} [options.redirect] - If true, enables RewriteEngine for redirection.
+   * @param {string} [options.redirectTarget] - The target URL for redirection.
+   * @param {boolean} [options.resetRouter] - If true, clears the existing router configuration before appending the new one.
+   * @returns {{disabled: boolean}} An object indicating if the service is disabled.
+   * @memberof LamppService
+   */
+  createApp({ port, host, path, directory, rootHostPath, redirect, redirectTarget, resetRouter }) {
+    if (!this.enabled()) return { disabled: true };
+
+    if (!this.ports.includes(port)) this.ports.push(port);
+    if (resetRouter) this.removeRouter();
+
+    const documentRoot = directory ? directory : `${getRootDirectory()}${rootHostPath}`;
+
+    // Append the new VirtualHost configuration
+    this.appendRouter(`
+Listen ${port}
+
+<VirtualHost *:${port}>
+  DocumentRoot "${documentRoot}"
+  ServerName ${host}:${port}
+
+  <Directory "${documentRoot}">
+    Options Indexes FollowSymLinks MultiViews
+    AllowOverride All
+    Require all granted
+  </Directory>
+
+  ${
+    redirect
+      ? `
+    RewriteEngine on
+
+    # Exclude the ACME challenge path for certificate renewals
+    RewriteCond %{REQUEST_URI} !^/.well-known/acme-challenge
+    RewriteRule ^(.*)$ ${redirectTarget}%{REQUEST_URI} [R=302,L]
+  `
+      : ''
+  }
+
+  # Custom Error Documents
+  ErrorDocument 400 ${path === '/' ? '' : path}/400.html
+  ErrorDocument 404 ${path === '/' ? '' : path}/400.html
+  ErrorDocument 500 ${path === '/' ? '' : path}/500.html
+  ErrorDocument 502 ${path === '/' ? '' : path}/500.html
+  ErrorDocument 503 ${path === '/' ? '' : path}/500.html
+  ErrorDocument 504 ${path === '/' ? '' : path}/500.html
+
+</VirtualHost>
+            
+`);
+
+    return { disabled: false };
+  }
+}
+
+/**
+ * @description Exported singleton instance of the LamppService class.
+ * This object is used to interact with the Lampp configuration and service.
+ * @memberof LamppService
+ * @type {LamppService}
+ */
+const Lampp = new LamppService();
+
+export { Lampp };
+
+// -- helper info --
+
+// ERR too many redirects:
+// Check: SELECT * FROM database.wp_options where option_name = 'siteurl' or option_name = 'home';
+// Check: wp-config.php
+// if (isset($_SERVER['HTTP_X_FORWARDED_PROTO']) && $_SERVER['HTTP_X_FORWARDED_PROTO'] === 'https') {
+//   $_SERVER['HTTPS'] = 'on';
+// }
+// For plugins:
+// define( 'FS_METHOD', 'direct' );
+
+// ErrorDocument 404 /custom_404.html
+// ErrorDocument 500 /custom_50x.html
+// ErrorDocument 502 /custom_50x.html
+// ErrorDocument 503 /custom_50x.html
+// ErrorDocument 504 /custom_50x.html
+
+// Respond When Error Pages are Directly Requested
+
+// <Files "custom_404.html">
+//     <If "-z %{ENV:REDIRECT_STATUS}">
+//         RedirectMatch 404 ^/custom_404.html$
+//     </If>
+// </Files>
+
+// <Files "custom_50x.html">
+//     <If "-z %{ENV:REDIRECT_STATUS}">
+//         RedirectMatch 404 ^/custom_50x.html$
+//     </If>
+// </Files>
+
+// Add www or https with htaccess rewrite
+
+// Options +FollowSymLinks
+// RewriteEngine On
+// RewriteCond %{HTTP_HOST} ^example.com [NC]
+// RewriteRule ^(.*)$ http://example.com/$1 [R=301,L]
+
+// Redirect http to https with htaccess rewrite
+
+// RewriteEngine On
+// RewriteCond %{SERVER_PORT} 80
+// RewriteRule ^(.*)$ https://www.example.com/$1 [R,L]
+
+// Redirect to HTTPS with www subdomain
+
+// RewriteEngine On
+// RewriteCond %{HTTPS} off [OR]
+// RewriteCond %{HTTP_HOST} ^www\. [NC]
+// RewriteCond %{HTTP_HOST} ^(?:www\.)?(.+)$ [NC]
+// RewriteRule ^ https://%1%{REQUEST_URI} [L,NE,R=301]