.gitignore

@@ -1,2 +1,6 @@
 node_modules/
+dist/
+build/
+
+# Do not upload API keys to Git
 config/secrets.json

README.md

@@ -8,3 +8,6 @@ Automation tool to reduce pain while taking CGT365
 - [PatternPacker](https://git.alanocull.com/alan/pattern-packer/src/branch/master/src/server/server.ts) uses some basic express hosting
 - Jira REST API docs for [issues](https://developer.atlassian.com/cloud/jira/platform/rest/v3/api-group-issues/#api-group-issues)
 - Gitea REST API [docs](https://git.alanocull.com/api/swagger)
+
+- [NODE FETCH](https://stackoverflow.com/questions/48433783/referenceerror-fetch-is-not-defined)
+- [Fetch](https://stackoverflow.com/questions/13121590/steps-to-send-a-https-request-to-a-rest-service-in-node-js)

buildwin.cmd

@@ -0,0 +1,4 @@
+rmdir dist\
+REM mkdir dist\public
+REM xcopy .\assets .\dist\public /e /h /y /f
+tsc && webpack --config .\webpack\development.js --watch

config/user_remap.json

@@ -1,9 +1,9 @@
 {
-    "alan": "arocull@purdue.edu",
-    "Will": "montgow@purdue.edu",
-    "connor": "celswort@purdue.edu",
-    "shelby": "shockada@purdue.edu",
-    "tommy": "thochste@purdue.edu",
-    "matt": "mcschule@purdue.edu",
-    "patrick": "ryan227@purdue.edu"
+    "alan": "712020:fb70534b-d978-4df7-b54f-85f948202227",
+    "Will": "622aee8d49c900007023fccb",
+    "connor": "60d139e09469280070f87286",
+    "shelby": "712020:67143da0-4371-437d-a48f-e7400c89649c",
+    "tommy": "712020:63e73e0a-6680-4546-8034-4a4732b6b383",
+    "matt": "712020:02aa3220-cfc4-4027-9e67-52387f5fa227",
+    "patrick": "712020:a18c4048-38d2-48ac-a450-21defd4a005c"
 }

package.json

@@ -4,8 +4,14 @@
   "description": "Tool for basic mirroring issues, tasks, and commits between Gitea and Jira",
   "main": "index.js",
   "scripts": {
-    "server": "node ./src/index.js",
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "all": "npm run clean && npm run build && npm run start",
+    "clean": "rm -rf build/ && rm -rf dist/",
+    "prebuild": "mkdir -p dist/public/ && cp -R assets/* dist/public/",
+    "build": "tsc && webpack --config ./webpack/development.js",
+    "rebuild": "npm run clean && npm run build",
+    "server": "node ./build/index.js",
+    "debug": "node ./build/index.js -debug",
+    "winserver": "node .\\build\\index.js"
   },
   "repository": {
     "type": "git",
@@ -22,7 +28,18 @@
   "license": "ISC",
   "dependencies": {
     "body-parser": "^1.20.2",
+    "lodash": "^4.17.21",
+    "node-fetch": "^2.7.0",
+    "ts-loader": "^9.5.1",
+    "webpack-node-externals": "^3.0.0"
+  },
+  "devDependencies": {
+    "@types/body-parser": "^1.19.5",
+    "@types/express": "^4.17.21",
+    "@types/lodash": "^4.14.202",
+    "@types/node-fetch": "^2.6.10",
     "express": "^4.18.2",
-    "lodash": "^4.17.21"
+    "typescript": "^5.3.3",
+    "webpack-cli": "^5.1.4"
   }
 }

src/index.js

@@ -1,69 +0,0 @@
-const fs = require('fs');
-const https = require('https');
-const bodyParser = require('body-parser');
-const _ = require('lodash');
-const express = require('express');
-const { append } = require('express/lib/response');
-
-// LOAD CONFIGURATION
-const CONFIG_DIRECTORY = `${process.cwd()}/config/`;
-/** @var {Object} */
-const CONFIG = JSON.parse(fs.readFileSync(`${CONFIG_DIRECTORY}server.json`, 'utf-8'));
-const SECRETS = JSON.parse(fs.readFileSync(`${CONFIG_DIRECTORY}secrets.json`, 'utf-8'));
-const PORT = CONFIG['port'];
-
-// BUILD OAUTH
-const OAUTH_JIRA = `${SECRETS['jira-email']}:${SECRETS['jira-token']}`;
-const OAUTH_GITEA = `token=${SECRETS['gitea-token']}`;
-
-const URL_GITEA = `${CONFIG['gitea']}/api/v1`;
-
-// INITIALIZE EXPRESS AND SET UP WEBHOOKS
-const app = express();
-app.use(bodyParser.json());
-
-app.get('/', (req, res) => {
-    console.log("Got request ", req.url);
-    res.send({'data':'nice'});
-})
-
-
-
-// FUNCTIONALITY
-const fetch_issues = () => {
-    /** @type {Object} */
-    _.forEach(CONFIG['repositories'], (loc, key) => {
-        console.log(`KEY [${key}]: ${loc}`);
-        if (key !== 'bot') { return } // TESTING ONLY, skip if not bot repo
-        // Search for all open issues in the given repository
-        const reqURL = `${URL_GITEA}/repos/${loc}/issues?state=open&${OAUTH_GITEA}`;
-
-        const options = {
-            hostname: URL_GITEA,
-            port: 443,
-            path: `/repos/${loc}/issues?state=open&${OAUTH_GITEA}`,
-            method: 'GET',
-            accept: 'application/json'
-        };
-
-        console.log(`Sending request to ${reqURL}`);
-        const req = https.request(options, (res) => {
-            res.setEncoding('utf-8');
-            res.on('data', (d) => {
-                console.log(d);
-            });
-        });
-        req.on('error', (e) => {
-          console.error(e);
-        });
-        req.end();
-
-    });
-}
-
-fetch_issues();
-
-// HOST
-app.listen(PORT, () => {
-    console.log(`Server is running on localhost:${PORT}, working in ${CONFIG_DIRECTORY}`)
-});

src/index.ts

@@ -0,0 +1,93 @@
+import _ from 'lodash'
+// import bodyParser from 'body-parser'
+// import express from 'express'
+
+import Issue from './issue';
+
+// Load configurations
+import CONFIG from '../config/server.json';
+import SECRETS from '../config/secrets.json';
+import uGiteaToJira from '../config/user_remap.json';
+import { fetchGitea, fetchJira } from './requests'
+
+const database: Issue[] = [];
+
+// GOAL: Copy issues over from Gitea to Jira
+// First, iterate through all relevant Gitea repositories and corresponding keys
+_.forEach(CONFIG['repositories'], (repoURL, repoName) => {
+    // Perform a search for all open issues
+    fetchGitea(`repos/${repoURL}/issues?state=open`)
+        .then((giteaSearchData) => {
+            // Convert search results to JSON for indexing
+            giteaSearchData.json().then((giteaSearch) => {
+                console.log(`Indexxing repository "${repoURL}" -----------`);
+
+                // For each search result, parse out an issue
+                _.forEach(giteaSearch, (ticket) => {
+                    // Generate issue from ticket JSON
+                    const issue = Issue.fromGitea(ticket, repoName);
+                    database.push(issue); // Save to our database for posterity
+
+                    // Now, search Jira issues (using JQL) to make sure this isn't already duplicated
+                    // To do this, we need to search for issues using our given Project key
+                    // ...then search for a matching title
+                    const jiraIssueSearch = `project = "${SECRETS['jira-project']}" and summary ~ "${issue.title_jira}"\nORDER BY created DESC`
+
+                    fetchJira(`issue/picker?currentJQL=${jiraIssueSearch}`)
+                        .then((jiraSearchData) => {
+                            // Convert search results to JSON for indexing
+                            jiraSearchData.json().then((jiraSearch) => {
+                                let issueFound: any = null;
+
+                                // Look through all sections of the Jira search
+                                _.forEach(jiraSearch['sections'], (searchSection) => {
+                                    const issueList: any[] = searchSection['issues']
+                                    if (issueList.length > 0) { // If any issues were found
+                                        issueFound = issueList[0]; // Select the first one (probably matches best)
+                                    }
+                                })
+
+                                // If the issue does NOT exist...
+                                if (issueFound === null) {
+                                    // ...then create one!
+                                    console.log(`\tIssue "${issue.title_jira}" not found on Jira, creating one...`);
+
+                                    return; // WOOPS DO NOT ALLOW CRASH AND BURN
+                                    // Send POST request to Jira, asking to create the issue
+                                    fetchJira('issue', 'POST', issue.toJira(uGiteaToJira, SECRETS['jira-project']))
+                                        .then((jiraIssueData) => {
+                                            // Convert our response back to JSON
+                                            jiraIssueData.json().then((jiraIssue) => {
+                                                issue.id_jira = jiraIssue['key']; // Store relevant information of newly created issue
+                                            })
+                                        })
+                                        .catch((reason) => {
+                                            console.error(`\tFailed to create issue "${issue.title_jira}" on Jira, for reason ${reason}`);
+                                        })
+                                } else {
+                                    console.log(`\tIssue "${issue.title_jira}" already existed, skipping`);
+                                }
+                            })
+                        })
+                        .catch((reason) => {
+                            console.error(`\tFailed to fetch issues from Jira project for reason ${reason}`);
+                        })
+                })
+            })
+        })
+        .catch((reason) => {
+            console.error(`\tFailed to fetch issues from Gitea repository "${repoURL}" for reason ${reason}`);
+        })
+})
+
+/*
+const app = express();
+app.use(bodyParser.json());
+app.get('/', (req, res) => {
+    res.send({'data':'nice'});
+})
+
+app.listen(CONFIG.port, () => {
+    console.log(`Server is running on localhost:${CONFIG.port}`)
+});
+*/

src/issue.ts

@@ -0,0 +1,110 @@
+import _ from "lodash";
+
+class Issue {
+    public id_gitea: number = -1;
+    public id_jira: number = -1;
+
+    constructor(
+        public repo: string,
+        public title: string,
+        protected desc: string = '',
+        protected labels: string[] = [],
+        protected reporter: string = '',
+        protected assignees: string[] = [],
+        protected open: boolean = true,
+        protected dueDate: string = '',
+    ) {}
+
+    /**
+     * @summary Constructs an issue from a Gitea JSON struct
+     * @param obj JSON Object
+     */
+    public static fromGitea(obj: any, repo: string): Issue {
+        const open = obj['open'] === 'open';
+        
+        // Fetch labels
+        const labels: string[] = [];
+        
+        _.forEach(obj['labels'], (label: any) => {
+            labels.push(label['name'])
+        });
+        
+        // Fetch assignees
+        const assignees: string[] = [];
+        _.forEach(obj['assignees'], (user: any) => {
+            assignees.push(user['login'])
+        });
+
+        // Get due date, if there is one
+        let due: string = '';
+        if (obj['due_date'] !== null) {
+            due = obj['due_date'];
+        }
+
+        const issue = new Issue(
+            repo,
+            obj['title'],
+            obj['body'],
+            labels,
+            obj['user']['login'],
+            assignees,
+            open,
+            due,
+        )
+        issue.id_gitea = obj['id']
+
+        return issue;
+    }
+
+    /**
+     * @summary Converts this to a Jira JSoN object
+     * https://developer.atlassian.com/server/jira/platform/jira-rest-api-examples/#creating-an-issue-examples
+     */
+    public toJira(remap: any, projectKey: string): any {
+        const obj: any = {
+            "labels": this.labels,
+            "summary": this.title_jira,
+            "description": {
+                "content": [
+                    {
+                        "content": [
+                            {
+                                "text": `${this.desc}\n\nManaged by GiteaJiraBot`,
+                                "type": "text"
+                            }
+                        ],
+                        "type": "paragraph"
+                    }
+                ],
+                "type": "doc",
+                "version": 1,
+            },
+            "reporter": {
+                "id": remap[this.reporter]
+            },
+            "project": {
+                "key": projectKey
+            },
+            "issuetype": {
+                // If there is a bug inside the labels, count the issue as a bug, else it's a task
+                "name": this.labels.includes('Bug') ? 'Bug' : 'Task'
+            }
+        }
+
+        if (this.assignees.length > 0) {
+            obj['assignee'] = remap[this.assignees[0]];
+        }
+        if (this.dueDate !== '') {
+            // obj['duedate'] = this.dueDate.slice(0, this.dueDate.indexOf('T'));
+        }
+
+        return {"fields": obj};
+    }
+
+    public get title_jira(): string {
+        return `${this.repo.toUpperCase()}: ${this.title}`;
+    }
+}
+
+export { Issue as default };
+

src/requests.ts

@@ -0,0 +1,43 @@
+import fetch from 'node-fetch'
+
+import CONFIG from '../config/server.json';
+import SECRETS from '../config/secrets.json';
+
+const OAUTH_JIRA = `${SECRETS['jira-email']}:${SECRETS['jira-token']}`;
+const OAUTH_GITEA = `token=${SECRETS['gitea-token']}`;
+
+function fetchGitea(protocol: string, method: string = 'GET', body: any = null) {
+    const options: RequestInit = {
+        method: method,
+        headers: {
+            'Authorization': SECRETS['gitea-token'],
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+        },
+    };
+
+    if (body !== null) {
+        options.body = JSON.stringify(body);
+    }
+
+    return fetch(`${CONFIG['gitea']}/api/v1/${protocol}`, <any>options)
+}
+
+function fetchJira(protocol: string, method: string = 'GET', body: any = null) {
+    const options: RequestInit = {
+        method: method,
+        headers: {
+            'Authorization': `Basic ${Buffer.from(OAUTH_JIRA).toString('base64')}`,
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+        },
+    };
+
+    if (body !== null) {
+        options.body = JSON.stringify(body);
+    }
+
+    return fetch(`https://${SECRETS['jira-site']}.atlassian.net/rest/api/3/${protocol}`, <any>options);
+}
+
+export { fetchGitea, fetchJira };

tsconfig.json

@@ -0,0 +1,109 @@
+{
+  "compilerOptions": {
+    /* Visit https://aka.ms/tsconfig to read more about this file */
+
+    /* Projects */
+    // "incremental": true,                              /* Save .tsbuildinfo files to allow for incremental compilation of projects. */
+    // "composite": true,                                /* Enable constraints that allow a TypeScript project to be used with project references. */
+    // "tsBuildInfoFile": "./.tsbuildinfo",              /* Specify the path to .tsbuildinfo incremental compilation file. */
+    // "disableSourceOfProjectReferenceRedirect": true,  /* Disable preferring source files instead of declaration files when referencing composite projects. */
+    // "disableSolutionSearching": true,                 /* Opt a project out of multi-project reference checking when editing. */
+    // "disableReferencedProjectLoad": true,             /* Reduce the number of projects loaded automatically by TypeScript. */
+
+    /* Language and Environment */
+    "target": "ESNext",                                  /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
+    "lib": ["ESNext"],                                        /* Specify a set of bundled library declaration files that describe the target runtime environment. */
+    // "jsx": "preserve",                                /* Specify what JSX code is generated. */
+    // "experimentalDecorators": true,                   /* Enable experimental support for legacy experimental decorators. */
+    // "emitDecoratorMetadata": true,                    /* Emit design-type metadata for decorated declarations in source files. */
+    // "jsxFactory": "",                                 /* Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h'. */
+    // "jsxFragmentFactory": "",                         /* Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'. */
+    // "jsxImportSource": "",                            /* Specify module specifier used to import the JSX factory functions when using 'jsx: react-jsx*'. */
+    // "reactNamespace": "",                             /* Specify the object invoked for 'createElement'. This only applies when targeting 'react' JSX emit. */
+    // "noLib": true,                                    /* Disable including any library files, including the default lib.d.ts. */
+    // "useDefineForClassFields": true,                  /* Emit ECMAScript-standard-compliant class fields. */
+    // "moduleDetection": "auto",                        /* Control what method is used to detect module-format JS files. */
+
+    /* Modules */
+    "module": "ESNext",                                /* Specify what module code is generated. */
+    // "rootDir": "./",                                  /* Specify the root folder within your source files. */
+    "moduleResolution": "Node",                     /* Specify how TypeScript looks up a file from a given module specifier. */
+    // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
+    // "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
+    // "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */
+    // "typeRoots": [],                                  /* Specify multiple folders that act like './node_modules/@types'. */
+    // "types": [],                                      /* Specify type package names to be included without being referenced in a source file. */
+    // "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */
+    // "moduleSuffixes": [],                             /* List of file name suffixes to search when resolving a module. */
+    // "allowImportingTsExtensions": true,               /* Allow imports to include TypeScript file extensions. Requires '--moduleResolution bundler' and either '--noEmit' or '--emitDeclarationOnly' to be set. */
+    // "resolvePackageJsonExports": true,                /* Use the package.json 'exports' field when resolving package imports. */
+    // "resolvePackageJsonImports": true,                /* Use the package.json 'imports' field when resolving imports. */
+    // "customConditions": [],                           /* Conditions to set in addition to the resolver-specific defaults when resolving imports. */
+    "resolveJsonModule": true,                        /* Enable importing .json files. */
+    // "allowArbitraryExtensions": true,                 /* Enable importing files with any extension, provided a declaration file is present. */
+    // "noResolve": true,                                /* Disallow 'import's, 'require's or '<reference>'s from expanding the number of files TypeScript should add to a project. */
+
+    /* JavaScript Support */
+    // "allowJs": true,                                  /* Allow JavaScript files to be a part of your program. Use the 'checkJS' option to get errors from these files. */
+    // "checkJs": true,                                  /* Enable error reporting in type-checked JavaScript files. */
+    // "maxNodeModuleJsDepth": 1,                        /* Specify the maximum folder depth used for checking JavaScript files from 'node_modules'. Only applicable with 'allowJs'. */
+
+    /* Emit */
+    // "declaration": true,                              /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
+    // "declarationMap": true,                           /* Create sourcemaps for d.ts files. */
+    // "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
+    // "sourceMap": true,                                /* Create source map files for emitted JavaScript files. */
+    // "inlineSourceMap": true,                          /* Include sourcemap files inside the emitted JavaScript. */
+    // "outFile": "./",                                  /* Specify a file that bundles all outputs into one JavaScript file. If 'declaration' is true, also designates a file that bundles all .d.ts output. */
+    "outDir": "./build",                                   /* Specify an output folder for all emitted files. */
+    // "removeComments": true,                           /* Disable emitting comments. */
+    // "noEmit": true,                                   /* Disable emitting files from a compilation. */
+    // "importHelpers": true,                            /* Allow importing helper functions from tslib once per project, instead of including them per-file. */
+    // "importsNotUsedAsValues": "remove",               /* Specify emit/checking behavior for imports that are only used for types. */
+    // "downlevelIteration": true,                       /* Emit more compliant, but verbose and less performant JavaScript for iteration. */
+    // "sourceRoot": "",                                 /* Specify the root path for debuggers to find the reference source code. */
+    // "mapRoot": "",                                    /* Specify the location where debugger should locate map files instead of generated locations. */
+    // "inlineSources": true,                            /* Include source code in the sourcemaps inside the emitted JavaScript. */
+    // "emitBOM": true,                                  /* Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files. */
+    // "newLine": "crlf",                                /* Set the newline character for emitting files. */
+    // "stripInternal": true,                            /* Disable emitting declarations that have '@internal' in their JSDoc comments. */
+    // "noEmitHelpers": true,                            /* Disable generating custom helper functions like '__extends' in compiled output. */
+    // "noEmitOnError": true,                            /* Disable emitting files if any type checking errors are reported. */
+    // "preserveConstEnums": true,                       /* Disable erasing 'const enum' declarations in generated code. */
+    // "declarationDir": "./",                           /* Specify the output directory for generated declaration files. */
+    // "preserveValueImports": true,                     /* Preserve unused imported values in the JavaScript output that would otherwise be removed. */
+
+    /* Interop Constraints */
+    // "isolatedModules": true,                          /* Ensure that each file can be safely transpiled without relying on other imports. */
+    // "verbatimModuleSyntax": true,                     /* Do not transform or elide any imports or exports not marked as type-only, ensuring they are written in the output file's format based on the 'module' setting. */
+    // "allowSyntheticDefaultImports": true,             /* Allow 'import x from y' when a module doesn't have a default export. */
+    "esModuleInterop": true,                             /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */
+    // "preserveSymlinks": true,                         /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */
+    "forceConsistentCasingInFileNames": true,            /* Ensure that casing is correct in imports. */
+
+    /* Type Checking */
+    "strict": true,                                      /* Enable all strict type-checking options. */
+    // "noImplicitAny": true,                            /* Enable error reporting for expressions and declarations with an implied 'any' type. */
+    // "strictNullChecks": true,                         /* When type checking, take into account 'null' and 'undefined'. */
+    // "strictFunctionTypes": true,                      /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */
+    // "strictBindCallApply": true,                      /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */
+    // "strictPropertyInitialization": true,             /* Check for class properties that are declared but not set in the constructor. */
+    // "noImplicitThis": true,                           /* Enable error reporting when 'this' is given the type 'any'. */
+    // "useUnknownInCatchVariables": true,               /* Default catch clause variables as 'unknown' instead of 'any'. */
+    // "alwaysStrict": true,                             /* Ensure 'use strict' is always emitted. */
+    // "noUnusedLocals": true,                           /* Enable error reporting when local variables aren't read. */
+    // "noUnusedParameters": true,                       /* Raise an error when a function parameter isn't read. */
+    // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
+    // "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
+    // "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */
+    // "noUncheckedIndexedAccess": true,                 /* Add 'undefined' to a type when accessed using an index. */
+    // "noImplicitOverride": true,                       /* Ensure overriding members in derived classes are marked with an override modifier. */
+    // "noPropertyAccessFromIndexSignature": true,       /* Enforces using indexed accessors for keys declared using an indexed type. */
+    // "allowUnusedLabels": true,                        /* Disable error reporting for unused labels. */
+    // "allowUnreachableCode": true,                     /* Disable error reporting for unreachable code. */
+
+    /* Completeness */
+    // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
+    "skipLibCheck": true                                 /* Skip type checking all .d.ts files. */
+  }
+}

webpack/development.js

@@ -0,0 +1,87 @@
+/* eslint-disable no-console */
+const _ = require('lodash');
+// eslint-disable-next-line
+const webpack = require('webpack');
+const path = require('path');
+// eslint-disable-next-line
+const nodeExternals = require('webpack-node-externals');
+const childProcess = require('child_process');
+
+// https://webpack.js.org/concepts/targets/
+// Also suggests splitting up the config into two pieces... Better for us anyway.
+
+const commonConfig = {
+  mode: 'development',
+  resolve: {
+    extensions: ['.tsx', '.ts', '.js', '.jsx'],
+  },
+  module: {
+    rules: [
+      {
+        test: /\.tsx?$/,
+        use: 'ts-loader',
+        exclude: /node_modules/,
+      },
+    ],
+  },
+};
+
+const serverConfig = _.defaultsDeep(_.cloneDeep(commonConfig), {
+  target: 'node',
+  entry: {
+    index: './src/index.ts',
+  },
+  output: {
+    filename: '[name].js',
+    path: path.resolve(__dirname, '../dist'),
+  },
+  externals: [nodeExternals()],
+  plugins: [
+    {
+      apply: (compiler) => {
+        let ps = null;
+        let watchEnabled = false;
+
+        async function startServer() {
+          const serverPath = path.join(__dirname, '../dist/index.js');
+          console.log(`Starting ${serverPath} ...`);
+          ps = childProcess.spawn('node', [serverPath]);
+
+          ps.stdout.on('data', (data) => {
+            process.stdout.write(data);
+          });
+
+          ps.stderr.on('data', (data) => {
+            process.stderr.write(data);
+          });
+
+          // Automatically restart the server if it crashes.
+          ps.once('close', () => {
+            // console.log('Crash detected, restarting ...');
+            // startServer();
+          });
+        }
+
+        // https://webpack.js.org/api/compiler-hooks/
+        compiler.hooks.afterEmit.tap('RunServer', () => {
+          if (watchEnabled) {
+            if (ps !== null) {
+              console.log('Killing old process ...');
+              ps.kill();
+              startServer(); // Start a new process
+            } else {
+              startServer();
+            }
+          }
+        });
+
+        compiler.hooks.watchRun.tap('RunServer', () => {
+          console.log('Watch enabled, will restart server process automatically');
+          watchEnabled = true;
+        });
+      },
+    },
+  ],
+});
+
+module.exports = [serverConfig];