yxorp 0.1.4 → 0.2.0

package/src/middleware/static.middleware.ts

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

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

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

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

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

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

@@ -1,21 +0,0 @@
-{
-  // 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
-  },
-}