yxorp 0.1.4 → 0.2.0

package/dist/services/rules-matchers/rewrite-rules-matcher.service.d.ts

@@ -0,0 +1,8 @@
+import { Config } from '../config.service';
+import { RewriteRule } from '../../types/yxorp-config';
+export declare class RewriteRulesMatcher {
+    private config;
+    constructor(config: Config);
+    match(url: string, method: string): RewriteRule | undefined;
+    params(url: string, rewriteRule: RewriteRule): Object | undefined;
+}

package/dist/services/rules-matchers/rewrite-rules-matcher.service.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RewriteRulesMatcher = void 0;
+const path_to_regexp_1 = require("path-to-regexp");
+class RewriteRulesMatcher {
+    constructor(config) {
+        this.config = config;
+    }
+    match(url, method) {
+        const rewriteRules = this.config.get().rewriteRules || [];
+        for (let rewriteRule of rewriteRules) {
+            if (rewriteRule.disable) {
+                continue;
+            }
+            if (rewriteRule.method.toLowerCase() !== method.toLowerCase()) {
+                continue;
+            }
+            const matchResult = (0, path_to_regexp_1.match)(rewriteRule.path, {
+                decode: decodeURIComponent,
+            })(url);
+            if (matchResult) {
+                return rewriteRule;
+            }
+        }
+    }
+    params(url, rewriteRule) {
+        const matchResult = (0, path_to_regexp_1.match)(rewriteRule.path, {
+            decode: decodeURIComponent,
+        })(url);
+        if (matchResult) {
+            return matchResult.params;
+        }
+    }
+}
+exports.RewriteRulesMatcher = RewriteRulesMatcher;

package/dist/services/yxorp-server.service.d.ts

@@ -0,0 +1,10 @@
+import { HttpServer } from './http-server.service';
+import { RemoteRulesMatcher } from './rules-matchers/remote-rules-matcher.service';
+import { RewriteRulesMatcher } from './rules-matchers/rewrite-rules-matcher.service';
+import { MockRulesMatcher } from './rules-matchers/mock-rules-matcher.service';
+import { Config } from './config.service';
+import { LoggerService } from './logger.service';
+export declare function createServer(config: Config, logger: LoggerService, rewriteRulesMatcher: RewriteRulesMatcher, mockRulesMatcher: MockRulesMatcher, remoteRulesMatcher: RemoteRulesMatcher): {
+    server: HttpServer;
+    listen: (port: string | number, callback?: () => void) => void;
+};

package/dist/services/yxorp-server.service.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createServer = void 0;
+const http_server_service_1 = require("./http-server.service");
+const http_proxy_service_1 = require("./http-proxy.service");
+const pipeline_service_1 = require("./pipeline.service");
+const bootstrap_middleware_1 = require("../middleware/bootstrap.middleware");
+const rawBody_middleware_1 = require("../middleware/rawBody.middleware");
+const proxyRes_middleware_1 = require("../middleware/proxyRes.middleware");
+const rewrite_middleware_1 = require("../middleware/rewrite.middleware");
+const proxy_middleware_1 = require("../middleware/proxy.middleware");
+const mock_middleware_1 = require("../middleware/mock.middleware");
+const static_middleware_1 = require("../middleware/static.middleware");
+function createServer(config, logger, rewriteRulesMatcher, mockRulesMatcher, remoteRulesMatcher) {
+    // 1. Proxy pipeline (outgoing responses) — no deps on proxy/server
+    const proxyPipeline = new pipeline_service_1.Pipeline();
+    proxyPipeline.use(new rawBody_middleware_1.RawBodyMiddleware(), new rewrite_middleware_1.RewriteMiddleware(logger), new proxyRes_middleware_1.ProxyResMiddleware(logger));
+    // 2. HttpProxy wraps the proxy pipeline
+    const proxy = new http_proxy_service_1.HttpProxy(proxyPipeline);
+    // 3. Server pipeline (incoming requests)
+    const serverPipeline = new pipeline_service_1.Pipeline();
+    serverPipeline.use(new static_middleware_1.StaticMiddleware(config, logger), new bootstrap_middleware_1.BootstrapMiddleware(rewriteRulesMatcher, mockRulesMatcher, logger), new mock_middleware_1.MockMiddleware(logger), new proxy_middleware_1.ProxyMiddleware(proxy, remoteRulesMatcher, config, logger));
+    // 4. HttpServer wraps the server pipeline
+    const server = new http_server_service_1.HttpServer(serverPipeline);
+    // 5. Attach proxy pipeline to proxyRes event
+    proxy.on('proxyRes', ((proxyRes, req, res) => {
+        proxy.execute(proxyRes, req, res);
+    }));
+    // 6. WebSocket upgrade handling
+    server.addListener('upgrade', (req, socket, head) => {
+        const url = req.url || '';
+        const proxyOptions = config.get().proxyOptions;
+        const remoteRule = remoteRulesMatcher.match(url, true);
+        const target = remoteRule
+            ? remoteRulesMatcher.toPath(url, remoteRule)
+            : undefined;
+        const options = {
+            ...proxyOptions,
+            prependPath: !target,
+            target: target || proxyOptions.target,
+        };
+        proxy.ws(req, socket, options, head).catch((error) => logger.info(error));
+    });
+    const listen = (port, callback) => {
+        server.listen(port, callback);
+    };
+    return { server, listen };
+}
+exports.createServer = createServer;

package/dist/types/yxorp-config.d.ts

@@ -0,0 +1,54 @@
+export interface YxorpConfig extends ConfigFile {
+    proxyOptions: Record<string, any>;
+}
+export interface ConfigFile {
+    target: string;
+    proxyPort: string | number;
+    scripts?: string[];
+    proxyHeaders?: Record<string, 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/dist/types/yxorp-config.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,38 +1,45 @@
-{
-  "name": "yxorp",
-  "version": "0.1.4",
-  "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",
-    "ts-node": "^10.9.1",
-    "tslib": "^2.6.2",
-    "typedi": "^0.10.0",
-    "typescript": "^5.2.2",
-    "winston": "^3.11.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"
-  },
-  "engines": {
-    "node": ">= 12"
-  }
-}
+{
+  "name": "yxorp",
+  "version": "0.2.0",
+  "description": "A local reverse proxy for rewriting, mocking, and debugging API responses.",
+  "files": [
+    "dist/",
+    "bin/",
+    "LICENSE",
+    "README.md"
+  ],
+  "main": "dist/index.js",
+  "bin": {
+    "yxorp": "bin/yxorp.js"
+  },
+  "scripts": {
+    "start": "nodemon src/index.ts",
+    "build": "tsc -p tsconfig.build.json",
+    "prepublishOnly": "npm run build",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "author": "Kirill Suntsov",
+  "license": "MIT",
+  "dependencies": {
+    "http-encoding": "^2.2.0",
+    "httpxy": "^0.5.3",
+    "mime": "^3.0.0",
+    "path-to-regexp": "^8.4.2",
+    "qs": "^6.15.2",
+    "tslib": "^2.8.1",
+    "winston": "^3.19.0"
+  },
+  "devDependencies": {
+    "@types/mime": "^3.0.4",
+    "@types/node": "^20.19.41",
+    "@types/qs": "^6.15.1",
+    "nodemon": "^3.0.1",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.2.2",
+    "vitest": "^4.1.7"
+  },
+  "engines": {
+    "node": ">= 18"
+  }
+}

package/.editorconfig

@@ -1,16 +0,0 @@
-# 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/src/index.ts

@@ -1,48 +0,0 @@
-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('./yxorp.json').toString()) as ConfigFile;
-} catch(e) {
-  console.error(e);
-  throw 'Can\'t read yxorp.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

@@ -1,87 +0,0 @@
-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

@@ -1,61 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,64 +0,0 @@
-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();
-    }
-  }
-
-}