yxorp 0.1.0

package/.editorconfig

@@ -0,0 +1,16 @@
+# Editor configuration, see http://editorconfig.org
+root = true
+
+[*]
+charset = utf-8
+indent_style = space
+indent_size = 2
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+[*.ts]
+quote_type = single
+
+[*.md]
+max_line_length = off
+trim_trailing_whitespace = false

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Kirill Suntsov
+
+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/README.md

@@ -0,0 +1,81 @@
+# Yxorp
+This is a simple CLI reverse proxy utility for rewriting or mocking API data. It is in early development and may contain many bugs 😊
+
+## Installation
+```
+npm i -g yxopr
+```
+## Usage
+Just run yxopr in folder which contains yxopr.json
+
+## Config
+Simple yxopr.json example:
+```json
+{
+  "#": "The site that will be proxied"
+  "target": "http://example.com/",
+  "port": 3002,
+  "#": "Makes static path with files in directory",
+  "staticRules": [
+    {
+      "path": "/some-path-on-server",
+      "directory": "./some-path-with-static-files",
+      "disable": false
+    }
+  ],
+  "#": "Scripts may be using for set some data for mock scripts",
+  "scripts": [
+    "./scripts/some-data.js"
+  ],
+  "#": "For matching paths in mockRules and rewriteRules uses https://www.npmjs.com/package/path-to-regex",
+  "#": "This rules uses to modify API data",
+  "mockRules": [
+    {
+      "method": "GET",
+      "path": "/api/example-one(.*)",
+      "script": "./mock/api/example-one.js",
+      "disable": false
+    }, {
+      "method": "GET",
+      "path": "/api/example-two(.*)",
+      "file": "./mock/api/example-two.json",
+      "statusCode": 200,
+      "disable": false
+    }
+  ]
+  "rewriteRules": [
+    {
+      "method": "GET",
+      "path": "/api/example-one(.*)",
+      "script": "./rewrite/api/example-one.js",
+      "disable": false
+    }, {
+      "method": "GET",
+      "path": "/api/example-two(.*)",
+      "file": "./rewrite/api/example-two.json",
+      "statusCode": 200,
+      "disable": false
+    }
+  ]
+}
+```
+
+## Mock script example
+```javascript
+var data = {
+  error: "some error",
+};
+
+res.statusCode = 500;
+res.end(Buffer.from(JSON.stringify(data)));
+```
+
+## Rewrite script example
+```javascript
+const data = JSON.parse(body.toString());
+
+data.modify = 'from js 123';
+
+result = Buffer.from(JSON.stringify(data));
+
+```

package/bin/yxorp.js

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+
+var path = require('path');
+var nodemon = require('nodemon');
+var nodemonDefaults = require('nodemon/lib/config/defaults');
+
+var pathToTsNode = path.normalize(__dirname + './../node_modules/.bin/ts-node');
+var filepath = path.normalize(__dirname + './../src/index.ts')
+
+nodemonDefaults.execMap.ts = pathToTsNode;
+
+nodemon({
+  script: filepath,
+  watch: ['yxopr.json']
+});
+
+nodemon.on('quit', function () {
+  console.log('Yxopr has quit');
+  process.exit();
+}).on('restart', function (files) {
+  console.log('Yxopr restarts...');
+});

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "yxorp",
+  "version": "0.1.0",
+  "description": "Yxorp is a reverse proxy for rewriting or mocking API data.",
+  "main": "src/index.ts",
+  "bin": {
+    "yxorp": "./bin/yxorp.js"
+  },
+  "scripts": {
+    "start": "nodemon src/index.ts"
+  },
+  "author": "Kirill Suntsov",
+  "license": "MIT",
+  "dependencies": {
+    "http-encoding": "^1.5.1",
+    "http-proxy": "^1.18.1",
+    "mime": "^3.0.0",
+    "nodemon": "^3.0.1",
+    "path-to-regexp": "^6.2.1",
+    "qs": "^6.11.2",
+    "reflect-metadata": "^0.1.13",
+    "typedi": "^0.10.0",
+    "yargs": "^17.7.2"
+  },
+  "devDependencies": {
+    "@types/http-proxy": "^1.17.11",
+    "@types/mime": "^3.0.1",
+    "@types/node": "^20.4.9",
+    "@types/qs": "^6.9.8",
+    "ts-node": "^10.9.1",
+    "tslib": "^2.6.1",
+    "typescript": "^5.1.6",
+    "winston": "^3.10.0"
+  },
+  "engines": {
+    "node": ">= 12"
+  }
+}

package/src/index.ts

@@ -0,0 +1,48 @@
+import 'reflect-metadata';
+
+import fs from 'fs';
+import path from 'path';
+import { Container } from 'typedi';
+import { ServerOptions } from 'http-proxy';
+import { YxorpServer } from './services/yxorp-server.service';
+import { ConfigFile } from './types/yxorp-config';
+import { ProxyConfigToken } from './services/config.service';
+
+
+let config: ConfigFile;
+
+try {
+  config = JSON.parse(fs.readFileSync('./yxopr.json').toString()) as ConfigFile;
+} catch(e) {
+  console.error(e);
+  throw 'Can\'t read yxopr.json'
+}
+
+globalThis.require = require;
+
+const proxyOptions: ServerOptions = {
+  target: config.target,
+  changeOrigin: true,
+  followRedirects: true,
+  secure: false,
+  localAddress: '0.0.0.0',
+  ws: true,
+  selfHandleResponse: true,
+};
+
+const proxyConfig = {
+  ...config,
+  proxyOptions,
+}
+
+config?.scripts?.forEach(script => {
+  require(path.join(process.cwd(), script));
+});
+
+Container.set(ProxyConfigToken, proxyConfig);
+
+const server = Container.get(YxorpServer);
+
+server.listen(config.proxyPort, () => {
+  console.log(`Yxorp server started successfully on http://localhost:${config.proxyPort}`);
+});

package/src/middleware/bootstrap.middleware.ts

@@ -0,0 +1,87 @@
+import { IncomingMessage } from 'http';
+import { Service } from 'typedi';
+import qs from 'qs';
+import { Middleware } from '../services/pipeline.service';
+import { RewriteRulesMatcher } from '../services/rules-matchers/rewrite-rules-matcher.service';
+import { MockRulesMatcher } from '../services/rules-matchers/mock-rules-matcher.service';
+import { LoggerService } from '../services/logger.service';
+
+
+@Service({
+  global: true
+})
+export class BootstrapMiddleware<T extends any[]> implements Middleware<T> {
+  constructor(
+    private rewriteRulesMatcher: RewriteRulesMatcher,
+    private mockRulesMatcher: MockRulesMatcher,
+    private logger: LoggerService,
+  ) {
+  }
+
+  public use(...args: [...T, () => void]): void {
+    const req: IncomingMessage = args[0] as IncomingMessage;
+    const next: () => void = args[args.length - 1];
+
+    try {
+      this.setRewriteRule(req);
+      this.setMockRule(req);
+      this.setQueryParams(req);
+
+      next();
+    } catch (e) {
+      this.logger.error(e);
+      next();
+    }
+  }
+
+  private setRewriteRule(req: IncomingMessage): void {
+    if (!req.url || !req.method) {
+      return;
+    }
+
+    const rewriteRule = this.rewriteRulesMatcher.match(req.url, req.method);
+
+    if (rewriteRule) {
+      req.rewriteRule = rewriteRule;
+
+      const rewriteRuleParams = this.rewriteRulesMatcher.params(req.url, rewriteRule);
+
+      if (rewriteRuleParams) {
+        req.rewriteRuleParams = rewriteRuleParams || {};
+      }
+    }
+  }
+
+  private setMockRule(req: IncomingMessage): void {
+    if (!req.url || !req.method) {
+      return;
+    }
+
+    const mockRule = this.mockRulesMatcher.match(req.url, req.method);
+
+    if (mockRule) {
+      req.mockRule = mockRule;
+
+      const mockRuleParams = this.mockRulesMatcher.params(req.url, mockRule);
+
+      if (mockRuleParams) {
+        req.mockRuleParams = mockRuleParams || {};
+      }
+    }
+  }
+
+  private setQueryParams(req: IncomingMessage): void {
+    if (!req.url) {
+      return;
+    }
+
+    const url = new URL(req.url, 'http://fake.com');
+    const query = qs.parse(url.search, {
+      ignoreQueryPrefix: true,
+    });
+
+    req.query = query;
+  }
+
+}
+

package/src/middleware/mock.middleware.ts

@@ -0,0 +1,61 @@
+import { Service } from 'typedi';
+import { ServerResponse, IncomingMessage } from 'http';
+import mime from 'mime';
+import fs from 'fs/promises';
+import path from 'path';
+import { Middleware } from '../services/pipeline.service';
+import { LoggerService } from '../services/logger.service';
+
+@Service({
+  global: true
+})
+export class MockMiddleware implements Middleware<[req: IncomingMessage, res: ServerResponse]> {
+  constructor(
+    private logger: LoggerService,
+  ) {
+  }
+
+  public async use(req: IncomingMessage, res: ServerResponse, next: () => void): Promise<void> {
+    try {
+      const mockRule = req?.mockRule;
+
+      if (!mockRule) {
+        next();
+        return;
+      }
+
+      if ('script' in mockRule) {
+        const file = await fs.readFile(path.resolve(mockRule.script));
+
+        const func = new Function('req, res', file.toString());
+        await func(req, res);
+
+        this.logger.info(`[MOCK BY SCRIPT] ${res.statusCode || 200} ${req.url}`);
+        return;
+      }
+
+      if ('file' in mockRule) {
+        const file = await fs.readFile(path.resolve(mockRule.file));
+        const mimeType = mime.getType(path.resolve(mockRule.file));
+
+        res.statusCode = mockRule.statusCode || res.statusCode;
+
+        if (mimeType) {
+          res.setHeader('content-type', mimeType);
+        }
+
+        res.setHeader('content-length', file.length);
+        res.end(file);
+
+        this.logger.info(`[MOCK BY FILE] ${res.statusCode} ${req.url}`);
+        return;
+      }
+
+      next();
+    } catch (e) {
+      this.logger.error(e);
+      next();
+    }
+  }
+
+}

package/src/middleware/proxy.middleware.ts

@@ -0,0 +1,42 @@
+import { Service } from 'typedi';
+import { IncomingMessage, ServerResponse } from 'http';
+import { HttpProxy } from '../services/http-proxy.service';
+import { RemoteRulesMatcher } from '../services/rules-matchers/remote-rules-matcher.service';
+import { Config } from '../services/config.service';
+import { Middleware } from '../services/pipeline.service';
+import { LoggerService } from '../services/logger.service';
+
+
+@Service({
+  global: true
+})
+export class ProxyMiddleware implements Middleware<[req: IncomingMessage, res: ServerResponse]> {
+  constructor(
+    private httpProxy: HttpProxy,
+    private remoteRulesMatcher: RemoteRulesMatcher,
+    private config: Config,
+    private logger: LoggerService,
+  ) {
+  }
+
+  public use(req: IncomingMessage, res: ServerResponse) {
+    const url = req.url || '';
+
+    const proxyOptions = this.config.get().proxyOptions;
+    const remoteRule = this.remoteRulesMatcher.match(url);
+    const target = remoteRule
+      ? this.remoteRulesMatcher.toPath(url, remoteRule)
+      : undefined;
+
+    const options = {
+      ...proxyOptions,
+      prependPath: !target,
+      target: target || proxyOptions.target,
+    };
+
+    this.httpProxy.web(
+      req, res, options, (error) => this.logger.error(error)
+    );
+  }
+
+}

package/src/middleware/proxyRes.middleware.ts

@@ -0,0 +1,34 @@
+import { Service } from 'typedi';
+import { IncomingMessage, ServerResponse } from 'http';
+import { Middleware } from '../services/pipeline.service';
+import { LoggerService } from '../services/logger.service';
+
+
+@Service({
+  global: true
+})
+export class ProxyResMiddleware implements Middleware<[proxyRes: IncomingMessage, req: IncomingMessage, res: ServerResponse]> {
+  constructor(
+    private logger: LoggerService,
+  ) {
+  }
+
+  public use(proxyRes: IncomingMessage, req: IncomingMessage, res: ServerResponse): void {
+    try {
+      for (let key in proxyRes.headers) {
+        res.setHeader(key, proxyRes.headers[key] as any);
+      }
+
+      res.statusCode = proxyRes.statusCode as number;
+      res.statusMessage = proxyRes.statusMessage as string;
+
+      const response: Buffer = proxyRes.rawBody || Buffer.from('');
+
+      res.setHeader('content-length', response.length);
+      res.end(response);
+    } catch(e) {
+      this.logger.error(e);
+    }
+  }
+
+}

package/src/middleware/rawBody.middleware.ts

@@ -0,0 +1,22 @@
+import { Service } from 'typedi';
+import { IncomingMessage, ServerResponse } from 'http';
+import { Middleware } from '../services/pipeline.service';
+
+@Service({
+  global: true
+})
+export class RawBodyMiddleware implements Middleware<[proxyRes: IncomingMessage, req: IncomingMessage, res: ServerResponse]> {
+  public use(proxyRes: IncomingMessage, req: IncomingMessage, res: ServerResponse, next: () => void): void {
+    const body: Uint8Array[] = [];
+
+    proxyRes.on('data', (chunk: Uint8Array) => {
+      body.push(chunk);
+    });
+
+    proxyRes.on('end', () => {
+      proxyRes.rawBody = Buffer.concat(body);
+      next();
+    });
+  }
+
+}

package/src/middleware/rewrite.middleware.ts

@@ -0,0 +1,64 @@
+import { Service } from 'typedi';
+import { IncomingMessage, ServerResponse } from 'http';
+import { SUPPORTED_ENCODING, encodeBuffer, decodeBuffer } from 'http-encoding'
+import fs from 'fs/promises';
+import path from 'path';
+import { Middleware } from '../services/pipeline.service';
+import { LoggerService } from '../services/logger.service';
+
+type RewriteFunction = (body: Buffer, proxyRes: IncomingMessage, req: IncomingMessage, res: ServerResponse) => Promise<Buffer> | Buffer;
+
+@Service({
+  global: true
+})
+export class RewriteMiddleware implements Middleware<[proxyRes: IncomingMessage, req: IncomingMessage, res: ServerResponse]> {
+  constructor(
+    private logger: LoggerService,
+  ) {
+  }
+
+  public async use(proxyRes: IncomingMessage, req: IncomingMessage, res: ServerResponse, next: () => void): Promise<void> {
+    const rewriteRule = req?.rewriteRule;
+
+    try {
+      if (!rewriteRule) {
+        next();
+        return;
+      }
+
+      const encoding = proxyRes.headers['content-encoding'] as SUPPORTED_ENCODING;
+      const response: Buffer = proxyRes.rawBody || Buffer.from('');
+
+      if ('script' in rewriteRule) {
+        const file = await fs.readFile(path.resolve(rewriteRule.script));
+        const encodedResponse = await decodeBuffer(response, encoding);
+        const func = new Function('body, proxyRes, req, res', 'var result;' + file + ';return result;') as RewriteFunction;
+
+        const rewritedResponse: Buffer = await func(encodedResponse, proxyRes, req, res);
+        proxyRes.rawBody = await encodeBuffer(rewritedResponse, encoding);
+
+        this.logger.info(`[REWRITE BY SCRIPT] ${proxyRes.statusCode} ${req.url}`);
+
+        next();
+        return;
+      }
+
+      if ('file' in rewriteRule) {
+        const file = await fs.readFile(path.resolve(rewriteRule.file));
+        proxyRes.rawBody = await encodeBuffer(file, encoding);
+        res.statusCode = rewriteRule.statusCode || res.statusCode;
+
+        this.logger.info(`[REWRITE BY FILE] ${proxyRes.statusCode} ${req.url}`);
+
+        next();
+        return;
+      }
+
+      next();
+    } catch (e) {
+      this.logger.error(e);
+      next();
+    }
+  }
+
+}

package/src/middleware/static.middleware.ts

@@ -0,0 +1,113 @@
+import { Service } from 'typedi';
+import { ServerResponse, IncomingMessage } from 'http';
+import path from 'path';
+import fs from 'fs/promises';
+import mime from 'mime';
+import { Dirent } from 'fs';
+import { Config } from '../services/config.service';
+import { Middleware } from '../services/pipeline.service';
+import { LoggerService } from '../services/logger.service';
+
+
+@Service({
+  global: true
+})
+export class StaticMiddleware implements Middleware<[req: IncomingMessage, res: ServerResponse]> {
+  constructor(
+    private config: Config,
+    private logger: LoggerService,
+  ) {
+  }
+
+  public async use(req: IncomingMessage, res: ServerResponse, next: () => void): Promise<void> {
+    try {
+      const staticRules = this.config.get().staticRules || [];
+
+      const url = new URL(req.url || '', 'http://fake.com');
+      const urlPath = url.pathname;
+
+      if (!staticRules) {
+        next();
+        return;
+      }
+
+      const currentStaticRule = staticRules.filter((staticRule) => {
+        return urlPath.startsWith(staticRule.path);
+      })[0];
+
+      if (!currentStaticRule) {
+        next();
+        return;
+      }
+
+      const pathToDirectory = path.resolve(currentStaticRule.directory);
+
+      const dirents = await this.readdir(pathToDirectory);
+
+      const filePath = dirents
+        .filter(dirent => !dirent.isDirectory())
+        .map(dirent => ({
+          urlPath: path.join(
+            currentStaticRule.path,
+            path.join(dirent.path, dirent.name).replace(pathToDirectory, '')
+          ).replace(/\\/g, '/'),
+          path: path.join(dirent.path, dirent.name).replace(/\\/g, '/'),
+        }
+        ))
+        .filter(dirent => {
+          const pathname = path.extname(urlPath)
+            ? urlPath
+            : path.join(urlPath, currentStaticRule.directoryIndex || '').replace(/\\/g, '/');
+
+          if (currentStaticRule.caseInsensitive) {
+            return dirent.urlPath.toLocaleLowerCase() === pathname.toLowerCase();
+          } else {
+            return dirent.urlPath === pathname;
+          }
+        })
+        .map(dirent => dirent.path)[0];
+
+
+      if (!filePath) {
+        next();
+        return;
+      }
+
+      const file = await fs.readFile(path.resolve(filePath));
+      const mimeType = mime.getType(path.resolve(filePath));
+
+      if (mimeType) {
+        res.setHeader('content-type', mimeType);
+      }
+
+      res.setHeader('content-length', file.length);
+      res.end(file);
+
+      this.logger.info(`[STATIC] ${req.url}`);
+    } catch (e) {
+      this.logger.error(e);
+      next();
+    }
+  }
+
+  private async readdir(pathname: string, subpathname?: string): Promise<Dirent[]> {
+    const files: Dirent[] = [];
+    const fullpath = path.join(pathname, subpathname || '');
+
+    const dirents = await fs.readdir(fullpath, {
+      withFileTypes: true,
+    });
+
+    for (let dirent of dirents) {
+      dirent.path = fullpath;
+      files.push(dirent);
+
+      if (dirent.isDirectory()) {
+        files.push(...await this.readdir(fullpath, dirent.name));
+      }
+    }
+
+    return files;
+  }
+
+}

package/src/services/config.service.ts

@@ -0,0 +1,26 @@
+import { Service, Token, Inject } from 'typedi';
+import { YxorpConfig } from "../types/yxorp-config";
+
+
+export const ProxyConfigToken = new Token<YxorpConfig>('ProxyConfigToken');
+
+@Service({
+  global: true
+})
+export class Config {
+  private config!: YxorpConfig;
+
+  constructor(
+    @Inject(ProxyConfigToken) private proxyConfig: YxorpConfig,
+  ) {
+    this.config = this.proxyConfig;
+  }
+
+  public set(config: YxorpConfig): void {
+    this.config = config;
+  }
+
+  public get(): YxorpConfig {
+    return this.config;
+  }
+}

package/src/services/http-proxy.service.ts

@@ -0,0 +1,25 @@
+import { Service } from 'typedi';
+import { IncomingMessage, ServerResponse} from 'http';
+import httpProxy from 'http-proxy';
+import { Pipeline } from "./pipeline.service";
+
+@Service({
+  global: true
+})
+export class HttpProxy {
+  private httpProxy = httpProxy.createProxyServer({});
+
+  constructor(
+    private pipeline: Pipeline<[proxyRes: IncomingMessage, req: IncomingMessage, res: ServerResponse]>,
+  ) {
+  }
+
+  public use = this.pipeline.use.bind(this.pipeline);
+  public execute = this.pipeline.execute.bind(this.pipeline);
+  public on = this.httpProxy.on.bind(this.httpProxy);
+  public addListener = this.httpProxy.addListener.bind(this.httpProxy);
+  public removeListener = this.httpProxy.removeListener.bind(this.httpProxy);
+  public web = this.httpProxy.web.bind(this.httpProxy);
+  public ws = this.httpProxy.ws.bind(this.httpProxy);
+
+}

package/src/services/http-server.service.ts

@@ -0,0 +1,24 @@
+import { Service } from 'typedi';
+import http, { IncomingMessage, Server, ServerResponse} from 'http';
+import { Pipeline } from './pipeline.service';
+
+@Service({
+  global: true
+})
+export class HttpServer {
+  private server: Server = http.createServer((req: IncomingMessage, res: ServerResponse) => {
+    this.pipeline.execute(req, res);
+  });
+
+  constructor(
+    private pipeline: Pipeline<[req: IncomingMessage, res: ServerResponse]>,
+  ) {
+  }
+
+  public use = this.pipeline.use.bind(this.pipeline);
+  public on = this.server.on.bind(this.server);
+  public addListener = this.server.addListener.bind(this.server);
+  public removeListener = this.server.removeListener.bind(this.server);
+  public listen = this.server.listen.bind(this.server);
+
+}

package/src/services/logger.service.ts

@@ -0,0 +1,21 @@
+import { Service } from 'typedi';
+import { createLogger, format, transports } from 'winston';
+
+
+@Service({
+  global: true
+})
+export class LoggerService {
+  private logger = createLogger({
+    format: format.combine(
+      format.colorize(),
+      format.simple(),
+    ),
+    transports: [new transports.Console],
+  });
+
+  public info = this.logger.info.bind(this.logger);
+  public error = this.logger.error.bind(this.logger);
+  public warn = this.logger.warn.bind(this.logger);
+  public debug = this.logger.debug.bind(this.logger);
+}

package/src/services/pipeline.service.ts

@@ -0,0 +1,44 @@
+import { Container, Service } from 'typedi';
+
+
+export interface Middleware<T extends any[]> {
+  use(...args: [...T, () => void]): void;
+  [k: string]: any;
+}
+
+export interface MiddlewareCtor<T extends any[]> {
+  new(...args: any): Middleware<T>;
+}
+export type Middlewares<T extends any[]> = MiddlewareCtor<T>[];
+
+@Service({
+  transient: true,
+})
+export class Pipeline<T extends any[]> {
+  private stack: Middlewares<T> = [];
+
+  public use(...middlewares: Middlewares<T>) {
+    this.stack.push(...middlewares);
+  }
+
+  public async execute(...args: [...T]) {
+    let prevIndex = -1;
+
+    const runner = async (index: number) => {
+      if (index === prevIndex) {
+        throw new Error('next() called multiple times');
+      }
+
+      prevIndex = index;
+
+      const middleware = Container.get(this.stack[index]);
+
+      await middleware.use(...args, () => {
+        return runner(index + 1);
+      });
+    }
+
+    await runner(0);
+  }
+
+}

package/src/services/rules-matchers/mock-rules-matcher.service.ts

@@ -0,0 +1,48 @@
+import { Service } from 'typedi';
+import { Config } from '../config.service';
+import { match } from 'path-to-regexp';
+import { MockRule } from '../../types/yxorp-config';
+
+
+@Service({
+  global: true
+})
+export class MockRulesMatcher {
+  constructor(
+    private config: Config
+  ) {
+  }
+
+  public match(url: string, method: string): MockRule | undefined {
+    const mockRules = this.config.get().mockRules || [];
+
+    for (let mockRule of mockRules) {
+      if (mockRule.disable) {
+        continue;
+      }
+
+      if (mockRule.method.toLowerCase() !== method.toLowerCase()) {
+        continue;
+      }
+
+      const matchResult = match<Record<string, string>>(mockRule.path, {
+        decode: decodeURIComponent,
+      })(url);
+
+      if (matchResult) {
+        return mockRule;
+      }
+    }
+  }
+
+  public params(url: string, mockRule: MockRule): Object | undefined {
+    const matchResult = match(mockRule.path, {
+      decode: decodeURIComponent,
+    })(url);
+
+    if (matchResult) {
+      return matchResult.params;
+    }
+  }
+
+}

package/src/services/rules-matchers/remote-rules-matcher.service.ts

@@ -0,0 +1,49 @@
+import { Service } from 'typedi';
+import { Config } from '../config.service';
+import { match, compile } from 'path-to-regexp';
+import { RemoteRule } from '../../types/yxorp-config';
+
+
+@Service({
+  global: true
+})
+export class RemoteRulesMatcher {
+  constructor(
+    private config: Config
+  ) {
+  }
+
+  public match(url: string, ws: boolean = false): RemoteRule | undefined {
+    const rules = this.config.get().remoteRules || [];
+
+    for (let rule of rules) {
+      if (rule.disable) {
+        continue;
+      }
+
+      if (!!rule.ws !== ws) {
+        continue;
+      }
+
+      const matchResult = match(rule.path, {
+        decode: decodeURIComponent
+      })(url);
+
+      if (matchResult) {
+        return rule;
+      }
+    }
+  }
+
+  public toPath(url: string, remoteRule: RemoteRule): string | undefined {
+    const matchResult = match(remoteRule.path, {
+      decode: decodeURIComponent
+    })(url);
+
+    if (matchResult) {
+      const toPath = compile(remoteRule.target, { validate: false });
+      return toPath(matchResult.params);
+    }
+  }
+
+}

package/src/services/rules-matchers/rewrite-rules-matcher.service.ts

@@ -0,0 +1,48 @@
+import { Service } from 'typedi';
+import { Config } from '../config.service';
+import { match } from 'path-to-regexp';
+import { RewriteRule } from '../../types/yxorp-config';
+
+
+@Service({
+  global: true
+})
+export class RewriteRulesMatcher {
+  constructor(
+    private config: Config
+  ) {
+  }
+
+  public match(url: string, method: string): RewriteRule | undefined {
+    const rewriteRules = this.config.get().rewriteRules || [];
+
+    for (let rewriteRule of rewriteRules) {
+      if (rewriteRule.disable) {
+        continue;
+      }
+
+      if (rewriteRule.method.toLowerCase() !== method.toLowerCase()) {
+        continue;
+      }
+
+      const matchResult = match<Record<string, string>>(rewriteRule.path, {
+        decode: decodeURIComponent,
+      })(url);
+
+      if (matchResult) {
+        return rewriteRule;
+      }
+    }
+  }
+
+  public params(url: string, rewriteRule: RewriteRule): Object | undefined {
+    const matchResult = match(rewriteRule.path, {
+      decode: decodeURIComponent,
+    })(url);
+
+    if (matchResult) {
+      return matchResult.params;
+    }
+  }
+
+}

package/src/services/yxorp-server.service.ts

@@ -0,0 +1,73 @@
+import { Service } from 'typedi';
+import { IncomingMessage, ServerResponse } from 'http';
+import { Duplex } from 'stream';
+import { BootstrapMiddleware } from '../middleware/bootstrap.middleware';
+import { ProxyMiddleware } from '../middleware/proxy.middleware';
+import { RawBodyMiddleware } from '../middleware/rawBody.middleware';
+import { ProxyResMiddleware } from '../middleware/proxyRes.middleware';
+import { RewriteMiddleware } from '../middleware/rewrite.middleware';
+import { MockMiddleware } from '../middleware/mock.middleware';
+import { StaticMiddleware } from '../middleware/static.middleware';
+import { HttpServer } from './http-server.service';
+import { HttpProxy } from './http-proxy.service';
+import { RemoteRulesMatcher } from './rules-matchers/remote-rules-matcher.service';
+import { Config } from './config.service';
+import { LoggerService } from './logger.service';
+
+
+@Service({
+  global: true
+})
+export class YxorpServer {
+  constructor(
+    private httpServer: HttpServer,
+    private httpProxy: HttpProxy,
+    private remoteRulesMatcher: RemoteRulesMatcher,
+    private config: Config,
+    private logger: LoggerService,
+  ) {
+    this.httpServer.use(
+      StaticMiddleware,
+      BootstrapMiddleware,
+      MockMiddleware,
+      ProxyMiddleware
+    );
+    this.httpProxy.use(
+      BootstrapMiddleware,
+      RawBodyMiddleware,
+      RewriteMiddleware,
+      ProxyResMiddleware,
+    );
+
+    this.httpProxy.on('proxyRes', this.onProxyRes);
+    this.httpServer.addListener('upgrade', this.onServerUpgrade);
+  }
+
+  private onProxyRes = (proxyRes: IncomingMessage, req: IncomingMessage, res: ServerResponse) => {
+    this.httpProxy.execute(proxyRes, req, res);
+  }
+
+  private onServerUpgrade = (req: IncomingMessage, socket: Duplex, head: Buffer): void => {
+    const url = req.url || '';
+
+    const proxyOptions = this.config.get().proxyOptions;
+    const remoteRule = this.remoteRulesMatcher.match(url, true);
+    const target = remoteRule
+      ? this.remoteRulesMatcher.toPath(url, remoteRule)
+      : undefined;
+
+    const options = {
+      ...proxyOptions,
+      prependPath: !target,
+      target: target || proxyOptions.target,
+    }
+
+    this.httpProxy.ws(
+      req, socket, head, options, (error) => this.logger.info(error)
+    );
+  }
+
+  public listen = this.httpServer.listen.bind(this.httpServer) as typeof this.httpServer.listen;
+
+}
+

package/src/types/http.d.ts

@@ -0,0 +1,10 @@
+declare module 'http' {
+  export interface IncomingMessage {
+    rawBody?: Buffer;
+    rewriteRule?: import("./yxorp-config").RewriteRule;
+    rewriteRuleParams?: Object;
+    mockRule?: import("./yxorp-config").MockRule;
+    mockRuleParams?: Object;
+    query?: Record<string, any>;
+  }
+}

package/src/types/yxorp-config.ts

@@ -0,0 +1,67 @@
+import { ServerOptions } from 'http-proxy';
+
+export interface YxorpConfig extends ConfigFile {
+  proxyOptions: ServerOptions;
+}
+
+export interface ConfigFile {
+  target: string;
+  proxyPort: string | number;
+  scripts?: string[];
+  remoteRules?: RemoteRule[];
+  staticRules?: StaticRule[];
+  mockRules?: MockRule[];
+  rewriteRules?: RewriteRule[];
+}
+
+export interface RemoteRule {
+  path: string;
+  target: string;
+  ws?: boolean;
+  disable?: boolean;
+}
+
+export type StaticRule = {
+  path: string;
+  directory: string;
+  caseInsensitive?: boolean;
+  directoryIndex?: string;
+  disable?: boolean;
+}
+
+export type MockFileRule = {
+  method: string;
+  path: string;
+  file: string;
+  statusCode?: number;
+  disable?: boolean;
+}
+
+export type MockScriptRule = {
+  method: string;
+  path: string;
+  script: string;
+  disable?: boolean;
+}
+
+export type MockRule = MockFileRule | MockScriptRule;
+
+
+export type RewriteFileRule = {
+  method: string;
+  path: string;
+  file: string;
+  statusCode?: number;
+  disable?: boolean;
+}
+
+export type RewriteScriptRule = {
+  method: string;
+  path: string;
+  script: string;
+  disable?: boolean;
+}
+
+export type RewriteRule = RewriteFileRule | RewriteScriptRule;
+
+

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  // This is an alias to @tsconfig/node16: https://github.com/tsconfig/bases
+  "extends": "ts-node/node12/tsconfig.json",
+  "ts-node": {
+    // It is faster to skip typechecking.
+    // Remove if you want ts-node to do typechecking.
+    // "transpileOnly": true,
+    "files": true,
+    "compilerOptions": {
+      // compilerOptions specified here will override those declared below,
+      // but *only* in ts-node.  Useful if you want ts-node and tsc to use
+      // different options with a single tsconfig.json.
+    }
+  },
+  "compilerOptions": {
+    // typescript options here
+    "resolveJsonModule": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true
+  },
+}