@modern-js/prod-server 1.0.1

package/tests/middleware.test.ts

@@ -0,0 +1,179 @@
+import path from 'path';
+import EventEmitter from 'events';
+import { Readable } from 'stream';
+import { createServer, Server } from 'http';
+import httpMocks from 'node-mocks-http';
+import portfinder from 'portfinder';
+import axios from 'axios';
+import { createContext } from '../src/libs/context';
+import { createStaticFileHandler } from '../src/libs/serve-file';
+import { createProxyHandler } from '../src/libs/proxy';
+
+describe('test middleware create factory', () => {
+  describe('should create static-file handler correctly', () => {
+    const middleware = createStaticFileHandler([
+      {
+        path: /static\/|upload\//,
+        target: path.join(__dirname, './fixtures/hosting-files'),
+      },
+    ]);
+
+    test('should get static file correctly', resolve => {
+      const req = httpMocks.createRequest({
+        path: '/static/index.js',
+        eventEmitter: Readable,
+      });
+      const res = httpMocks.createResponse({ eventEmitter: EventEmitter });
+      const mockContext = createContext(req, res);
+      res.on('finish', () => {
+        expect(res._getBuffer().toString().trim()).toBe(
+          "console.info('index.js');",
+        );
+        resolve();
+      });
+
+      middleware(mockContext, () => {
+        throw new Error('should not happened');
+      });
+    });
+
+    test('should miss static file correctly', resolve => {
+      const req = httpMocks.createRequest({
+        path: '/static/index.css',
+        eventEmitter: Readable,
+      });
+      const res = httpMocks.createResponse({ eventEmitter: EventEmitter });
+      const mockContext = createContext(req, res);
+      res.on('finish', () => {
+        throw new Error('should not happened');
+      });
+
+      middleware(mockContext, () => {
+        req.destroy();
+        expect(true).toBeTruthy();
+        resolve();
+      });
+    });
+  });
+
+  jest.setTimeout(1000 * 10);
+  describe('should create proxy handler correctly', () => {
+    test('should return null if no options', () => {
+      expect(createProxyHandler(null as any)).toBeNull();
+    });
+
+    let sourceServerPort = 8080;
+    let sourceServer: Server | null = null;
+    beforeAll(async () => {
+      let done: any;
+      const promise = new Promise(resolve => (done = resolve));
+      sourceServerPort = await portfinder.getPortPromise();
+      sourceServer = createServer((req, res) => {
+        res.setHeader('Access-Control-Allow-Origin', '*');
+        res.write(req.url?.slice(1));
+        res.end();
+      }).listen(sourceServerPort, done);
+      return promise;
+    });
+
+    afterAll(() => {
+      if (sourceServer) {
+        sourceServer.close();
+      }
+    });
+
+    test('should proxy correctly use simply options', async () => {
+      const port = await portfinder.getPortPromise();
+      const middlewares = createProxyHandler({
+        '/simple': `http://localhost:${sourceServerPort}`,
+      });
+      const proxyHandler = middlewares![0];
+
+      const server = createServer((req, res) => {
+        const context = createContext(req, res);
+        proxyHandler(context, () => {
+          throw new Error('should not happened');
+        });
+      }).listen(port);
+
+      try {
+        const { data } = await axios.get(`http://localhost:${port}/simple`);
+        expect(data).toBe('simple');
+      } finally {
+        server.close();
+      }
+    });
+
+    test('should proxy correctly use simply obj options', async () => {
+      const port = await portfinder.getPortPromise();
+      const middlewares = createProxyHandler({
+        '/simple-obj': {
+          target: `http://localhost:${sourceServerPort}`,
+        },
+      });
+      const proxyHandler = middlewares![0];
+
+      const server = createServer((req, res) => {
+        const context = createContext(req, res);
+        proxyHandler(context, () => {
+          throw new Error('should not happened');
+        });
+      }).listen(port);
+
+      try {
+        const { data } = await axios.get(`http://localhost:${port}/simple-obj`);
+        expect(data).toBe('simple-obj');
+      } finally {
+        server.close();
+      }
+    });
+
+    test('should proxy correctly use context options', async () => {
+      const port = await portfinder.getPortPromise();
+      const middlewares = createProxyHandler({
+        context: '/context',
+        target: `http://localhost:${sourceServerPort}`,
+      });
+      const proxyHandler = middlewares![0];
+
+      const server = createServer((req, res) => {
+        const context = createContext(req, res);
+        proxyHandler(context, () => {
+          throw new Error('should not happened');
+        });
+      }).listen(port);
+
+      try {
+        const { data } = await axios.get(`http://localhost:${port}/context`);
+        expect(data).toBe('context');
+      } finally {
+        server.close();
+      }
+    });
+
+    test('should proxy correctly use array options', async () => {
+      const port = await portfinder.getPortPromise();
+      const middlewares = createProxyHandler([
+        {
+          context: '/array',
+          target: `http://localhost:${sourceServerPort}`,
+        },
+      ]);
+      const proxyHandler = middlewares![0];
+
+      const server = createServer((req, res) => {
+        const context = createContext(req, res);
+        proxyHandler(context, () => {
+          throw new Error('should not happened');
+        });
+      }).listen(port);
+
+      try {
+        const { data } = await axios.get(`http://localhost:${port}/array`);
+        expect(data).toBe('array');
+      } finally {
+        server.close();
+      }
+    });
+  });
+});

package/tests/render.test.ts

@@ -0,0 +1,102 @@
+import path from 'path';
+import { render } from '../src/libs/render/ssr';
+import { handleDirectory } from '../src/libs/render/static';
+import { LruReader } from '../src/libs/render/reader';
+
+describe('test render function', () => {
+  test('should return content correctly ', async () => {
+    const renderResult = await render(
+      {
+        params: {},
+        pathname: '/foo',
+        host: 'localhost:8080',
+        query: {},
+        url: 'localhost:8080/foo',
+        cookieMap: {},
+        headers: {},
+      } as any,
+      {
+        urlPath: '/foo',
+        bundle: 'bundle.js',
+        distDir: path.join(__dirname, 'fixtures', 'ssr'),
+        template: 'tpl.html',
+        entryName: 'foo',
+        staticGenerate: false,
+      } as any,
+      {
+        extendSSRContext: () => {
+          // empty
+        },
+      } as any,
+    );
+
+    expect(renderResult.content).toMatch('Modern.js');
+    expect(renderResult.contentType).toMatch('text/html; charset=utf-8');
+  });
+
+  test('should handle directory for .html correctly', async () => {
+    const entryPath = path.join(__dirname, 'fixtures', 'static-dir');
+
+    const res1 = await handleDirectory(
+      {
+        path: '/modern/bar',
+      } as any,
+      entryPath,
+      '/modern',
+    );
+
+    expect(res1?.content.toString()).toMatch('bar');
+  });
+
+  test('should handle directory for index.html correctly', async () => {
+    const entryPath = path.join(__dirname, 'fixtures', 'static-dir');
+
+    const res1 = await handleDirectory(
+      {
+        path: '/modern/foo',
+      } as any,
+      entryPath,
+      '/modern',
+    );
+
+    expect(res1?.content.toString()).toMatch('foo');
+  });
+
+  test('should handle directory for /index.html correctly', async () => {
+    const entryPath = path.join(__dirname, 'fixtures', 'static-dir');
+
+    const res1 = await handleDirectory(
+      {
+        path: '/modern/baz/',
+      } as any,
+      entryPath,
+      '/modern',
+    );
+
+    expect(res1?.content.toString()).toMatch('baz');
+  });
+
+  test('should reader work correctly', async () => {
+    const reader = new LruReader();
+    const dir = path.join(__dirname, 'fixtures', 'reader');
+
+    const nullRes = await reader.read(path.join(dir, 'foo.ts'));
+    expect(nullRes).toBeNull();
+
+    const dirRes = await reader.read(path.join(dir, 'test-dir'));
+    expect(dirRes).toBeNull();
+
+    const res = await reader.read(path.join(dir, 'index.ts'));
+    expect(res).not.toBeNull();
+    expect(res?.content.toString()).toMatch('modern');
+
+    const res1 = await reader.read(path.join(dir, 'index.ts'));
+    expect(res1).not.toBeNull();
+    expect(res1?.content.toString()).toMatch('modern');
+
+    reader.update();
+    const res2 = await reader.read(path.join(dir, 'index.ts'));
+    expect(res2).not.toBeNull();
+    expect(res2?.content.toString()).toMatch('modern');
+  });
+});

package/tests/route.test.ts

@@ -0,0 +1,77 @@
+import { RouteMatchManager, RouteMatcher } from '../src/libs/route';
+import spec from './fixtures/route-spec/index.json';
+import dynamic from './fixtures/route-spec/dynamic.json';
+
+describe('test route', () => {
+  describe('test route matcher', () => {
+    test('should matcher work correctyl with simple spec', () => {
+      const routeSpec = spec.routes[0];
+      const matcher = new RouteMatcher(routeSpec);
+      expect(matcher.spec).toBe(routeSpec);
+      expect(matcher.urlPath).toBe(routeSpec.urlPath);
+      expect(matcher.urlReg).toBeUndefined();
+      expect(matcher.urlMatcher).toBeUndefined();
+
+      const { isSSR, isApi, isSPA, urlPath, entryName, entryPath } =
+        matcher.generate('');
+
+      expect(isSSR).toBeTruthy();
+      expect(isApi).toBeFalsy();
+      expect(isSPA).toBeTruthy();
+      expect(urlPath).toBe(routeSpec.urlPath);
+      expect(entryName).toBe(routeSpec.entryName);
+      expect(entryPath).toBe(routeSpec.entryPath);
+
+      expect(matcher.matchEntry('entry')).toBeTruthy();
+      expect(matcher.matchEntry('home')).toBeFalsy();
+      expect(matcher.matchLength('/entry')).toBe(6);
+      expect(matcher.matchUrlPath('/entry')).toBeTruthy();
+      expect(matcher.matchUrlPath('/home')).toBeFalsy();
+    });
+  });
+
+  describe('test route manager', () => {
+    test('should manager work correctly with simple spec', async () => {
+      const manager = new RouteMatchManager();
+      expect(manager.matchers.length).toBe(0);
+      manager.reset(spec.routes);
+      expect(manager.matchers.length).toBe(3);
+
+      const matchedByEntry = manager.matchEntry('home');
+      expect(matchedByEntry).toBeDefined();
+      expect(matchedByEntry?.generate('').entryName).toBe('home');
+
+      const matchedByUrl = manager.match('/entry');
+      expect(matchedByUrl).toBeDefined();
+      expect(matchedByUrl?.generate('').entryName).toBe('entry');
+
+      const SSRUrlBundles = manager.getBundles();
+      expect(SSRUrlBundles).toEqual(['bundles/entry.js', 'bundles/home.js']);
+
+      manager.reset([]);
+      expect(manager.matchers.length).toBe(0);
+    });
+
+    test('should manager work correctly with dynamic spec', async () => {
+      const manager = new RouteMatchManager();
+      expect(manager.matchers.length).toBe(0);
+      manager.reset(dynamic.routes);
+      expect(manager.matchers.length).toBe(1);
+
+      const matched = manager.match('/entry/001');
+      expect(matched).toBeDefined();
+      const route = matched?.generate('/entry/001');
+      expect(route?.entryName).toBe('entry');
+      expect(route?.params).toEqual({ id: '001' });
+
+      const matchedWithTrail = manager.match('/entry/001/a');
+      expect(matchedWithTrail).toBeDefined();
+      const routeWithTrail = matchedWithTrail?.generate('/entry/001/a');
+      expect(routeWithTrail?.entryName).toBe('entry');
+      expect(routeWithTrail?.params).toEqual({ id: '001' });
+
+      const miss = manager.match('/entry');
+      expect(miss).toBeUndefined();
+    });
+  });
+});

package/tests/server.test.ts

@@ -0,0 +1,101 @@
+import path from 'path';
+import { defaultsConfig, NormalizedConfig } from '@modern-js/core';
+import { ModernServerContext, NextFunction } from '@modern-js/types';
+import createServer, { Server } from '../src';
+import { ModernServer } from '../src/server/modern-server';
+
+describe('test server', () => {
+  test('should throw error when ', resolve => {
+    try {
+      createServer(null as any);
+    } catch (e: any) {
+      expect((e as Error).message).toBe(
+        'can not start mserver without options',
+      );
+      resolve();
+    }
+  });
+
+  test('shoule get modern server instance', async () => {
+    const server = await createServer({
+      config: defaultsConfig as NormalizedConfig,
+      pwd: path.join(__dirname, './fixtures/pure'),
+    });
+    expect(server instanceof Server).toBe(true);
+  });
+
+  describe('shoule get production modern server instance', () => {
+    const appDirectory = path.join(__dirname, './fixtures/pure');
+
+    test('should init server correctly', async () => {
+      const server = await createServer({
+        config: defaultsConfig as NormalizedConfig,
+        pwd: appDirectory,
+      });
+      const modernServer = (server as any).server;
+
+      const {
+        pwd,
+        distDir,
+        workDir,
+        conf,
+        handlers,
+        isDev,
+        staticGenerate,
+        presetRoutes,
+      } = modernServer;
+      expect(pwd).toBe(appDirectory);
+      expect(distDir).toBe(path.join(appDirectory, 'dist'));
+      expect(workDir).toBe(distDir);
+      expect(conf).toBe(defaultsConfig);
+      expect(handlers).toBeDefined();
+      expect(isDev).toBeFalsy();
+      expect(staticGenerate).toBeFalsy();
+      expect(presetRoutes).toBeUndefined();
+    });
+
+    test('should add handler correctly', async () => {
+      const server = await createServer({
+        config: defaultsConfig as NormalizedConfig,
+        pwd: appDirectory,
+      });
+      const modernServer = (server as any).server;
+
+      const len = modernServer.handlers.length;
+
+      const syncHandler = (ctx: ModernServerContext, next: NextFunction) => {
+        console.info(ctx.url);
+        next();
+      };
+      modernServer.addHandler(syncHandler);
+
+      const newLen = modernServer.handlers.length;
+      expect(len + 1).toBe(newLen);
+      expect(modernServer.handlers[newLen - 1]).not.toBe(syncHandler);
+
+      const asyncHandler = async (
+        ctx: ModernServerContext,
+        next: NextFunction,
+      ) => {
+        console.info(ctx.url);
+        next();
+      };
+      modernServer.addHandler(asyncHandler);
+      const nextLen = modernServer.handlers.length;
+
+      expect(newLen + 1).toBe(nextLen);
+      expect(modernServer.handlers[nextLen - 1]).toBe(asyncHandler);
+    });
+
+    test('should get request handler correctly', async () => {
+      const server = await createServer({
+        config: defaultsConfig as NormalizedConfig,
+        pwd: appDirectory,
+      });
+
+      const modernServer: ModernServer = (server as any).server;
+      const handler = modernServer.getRequestHandler();
+      expect(typeof handler === 'function').toBeTruthy();
+    });
+  });
+});

package/tests/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "extends": "@modern-js/tsconfig/base",
+  "compilerOptions": {
+    "declaration": false,
+    "jsx": "preserve",
+    "baseUrl": "./",
+    "isolatedModules": true,
+    "sourceMap": true
+  },
+  "paths": {},
+  "exclude": ["src/__test__/fixtures/**"]
+}

package/tests/utils.test.ts

@@ -0,0 +1,106 @@
+import { compile } from 'path-to-regexp';
+import {
+  noop,
+  mergeExtension,
+  toMessage,
+  createErrorDocument,
+  createMiddlewareCollecter,
+  getStaticReg,
+} from '../src/utils';
+
+describe('test server utils', () => {
+  test('should get nothing from noop', async () => {
+    const rtn = noop();
+    expect(rtn).toBeUndefined();
+  });
+
+  test('should merge extension', () => {
+    const middleware = ['foo', 'baz'];
+    const extension = mergeExtension(middleware);
+    expect(extension.middleware).toEqual(middleware);
+  });
+
+  describe('test some case by toMessage func', () => {
+    test('should get message from error like object', () => {
+      const error = new Error('some error happened');
+      const message = toMessage('error info', error);
+      expect(message).toBe('error info: some error happened');
+    });
+
+    test('should get message from error message', () => {
+      const errorMsg = 'some error happened';
+      const message = toMessage('error info', errorMsg);
+      expect(message).toBe('error info: some error happened');
+    });
+  });
+
+  test('should return document text', () => {
+    const doc = createErrorDocument(302, 'redirect');
+    expect(doc).toMatch('302');
+    expect(doc).toMatch('redirect');
+    expect(doc).toMatch('302: redirect');
+  });
+
+  describe('test middleware collector', () => {
+    test('shoule return web middleware correctly', () => {
+      const { addWebMiddleware, getMiddlewares } = createMiddlewareCollecter();
+
+      const before = getMiddlewares();
+      expect(before.web).toEqual([]);
+
+      const middleware = async () => {
+        // empty
+      };
+      addWebMiddleware(middleware);
+      const after = getMiddlewares();
+      expect(after.web).toEqual([middleware]);
+    });
+
+    test('shoule return api middleware correctly', () => {
+      const { addAPIMiddleware, getMiddlewares } = createMiddlewareCollecter();
+
+      const before = getMiddlewares();
+      expect(before.web).toEqual([]);
+
+      const middleware = async () => {
+        // empty
+      };
+      addAPIMiddleware(middleware);
+      const after = getMiddlewares();
+      expect(after.api).toEqual([middleware]);
+    });
+  });
+
+  test('should return full path', () => {
+    const fn = compile('/home/:id', { encode: encodeURIComponent });
+    expect(fn({ id: 2 })).toBe('/home/2');
+  });
+
+  describe('test create static reg', () => {
+    test('should test static path correctly', () => {
+      const reg = getStaticReg();
+      expect(reg.test('/static')).toBeTruthy();
+      expect(reg.test('/upload')).toBeTruthy();
+    });
+
+    test('should test custom static path correctly', () => {
+      const reg = getStaticReg({
+        cssPath: 'static-css',
+      });
+      expect(reg.test('/static-css')).toBeTruthy();
+    });
+
+    test('should test favicon path correctly', () => {
+      const reg = getStaticReg({
+        favicon: 'index.icon',
+        faviconByEntries: {
+          foo: 'foo.icon',
+          baz: 'baz.icon',
+        },
+      });
+      expect(reg.test('/index.icon')).toBeTruthy();
+      expect(reg.test('/foo.icon')).toBeTruthy();
+      expect(reg.test('/baz.icon')).toBeTruthy();
+    });
+  });
+});

package/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "extends": "@modern-js/tsconfig/base",
+  "compilerOptions": {
+    "declaration": false,
+    "jsx": "preserve",
+    "baseUrl": "./",
+    "esModuleInterop": true,
+    "paths": {}
+  },
+  "include": ["src"]
+}