yxorp 0.1.3 → 0.1.5

package/src/middleware/static.middleware.ts

@@ -1,113 +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;
-  }
-
-}
+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

@@ -1,26 +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;
-  }
-}
+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

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

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

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

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

@@ -1,48 +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;
-    }
-  }
-
-}
+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;
+    }
+  }
+
+}