yxorp 0.1.2 → 0.1.4

package/src/middleware/mock.middleware.ts

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