feat: CORS (#5)

typeofweb · web-flow · commit 658a612346c3 · 2021-06-16T21:21:53.000+02:00
diff --git a/README.md b/README.md
@@ -4,7 +4,6 @@
 const app = await createApp({
   host: 'localhost',
   port: 3000,
-  cors: [],
 });
 
 app.plugin(dbPlugin);
diff --git a/__tests__/events.test.ts b/__tests__/events.test.ts
@@ -10,11 +10,7 @@ declare module '../src' {
 
 describe('events', () => {
   it('should emit system events server, request and response', async () => {
-    const app = await createApp({
-      hostname: 'localhost',
-      port: 3000,
-      cors: [],
-    }).route({
+    const app = createApp({}).route({
       path: '/users/:userId/invoices/:invoiceId',
       method: 'post',
       validation: {
@@ -45,11 +41,7 @@ describe('events', () => {
   });
 
   it('should allow emitting custom events', async () => {
-    const app = await createApp({
-      hostname: 'localhost',
-      port: 3000,
-      cors: [],
-    }).route({
+    const app = createApp({}).route({
       path: '/users',
       method: 'post',
       validation: {
diff --git a/__tests__/handler.test-d.ts b/__tests__/handler.test-d.ts
@@ -3,11 +3,7 @@ import { expectType } from 'tsd';
 
 import { createApp } from '../src';
 
-const app = createApp({
-  hostname: 'localhost',
-  port: 3000,
-  cors: [],
-});
+const app = createApp({});
 
 void app.route({
   path: '/users/:userId/invoices/:invoiceId',
diff --git a/__tests__/handler.test.ts b/__tests__/handler.test.ts
@@ -5,11 +5,7 @@ import { createApp } from '../src';
 describe('handler', () => {
   describe('validation', () => {
     it('should error on invalid parameters', async () => {
-      const app = createApp({
-        hostname: 'localhost',
-        port: 3000,
-        cors: [],
-      }).route({
+      const app = createApp({}).route({
         path: '/users/:userId/invoices/:invoiceId',
         method: 'get',
         validation: {
@@ -54,11 +50,7 @@ Object {
     });
 
     it('should error on invalid query', async () => {
-      const app = createApp({
-        hostname: 'localhost',
-        port: 3000,
-        cors: [],
-      }).route({
+      const app = createApp({}).route({
         path: '/users',
         method: 'get',
         validation: {
@@ -98,11 +90,7 @@ Object {
     });
 
     it('should error on invalid payload', async () => {
-      const app = createApp({
-        hostname: 'localhost',
-        port: 3000,
-        cors: [],
-      }).route({
+      const app = createApp({}).route({
         path: '/users',
         method: 'post',
         validation: {
@@ -152,11 +140,7 @@ Object {
     });
 
     it('should return 500 on invalid response', async () => {
-      const app = createApp({
-        hostname: 'localhost',
-        port: 3000,
-        cors: [],
-      }).route({
+      const app = createApp({}).route({
         path: '/users',
         method: 'get',
         validation: {
@@ -184,11 +168,7 @@ Object {
     });
 
     it('should parse and validate query, params and payload', async () => {
-      const app = createApp({
-        hostname: 'localhost',
-        port: 3000,
-        cors: [],
-      }).route({
+      const app = createApp({}).route({
         path: '/users/:userId/invoices/:invoiceId',
         method: 'post',
         validation: {
@@ -222,11 +202,7 @@ Object {
 
   describe('happy path', () => {
     it('should return data when all validation passes', async () => {
-      const app = createApp({
-        hostname: 'localhost',
-        port: 3000,
-        cors: [],
-      }).route({
+      const app = createApp({}).route({
         path: '/users/:userId/invoices/:invoiceId',
         method: 'post',
         validation: {
@@ -256,11 +232,7 @@ Object {
     });
 
     it('should return 204 on empty response', async () => {
-      const app = createApp({
-        hostname: 'localhost',
-        port: 3000,
-        cors: [],
-      }).route({
+      const app = createApp({}).route({
         path: '/users',
         method: 'get',
         validation: {},
@@ -278,11 +250,7 @@ Object {
       const uniqueRequestIds = new Set<string>();
       const uniqueServerIds = new Set<string>();
 
-      const app = createApp({
-        hostname: 'localhost',
-        port: 3000,
-        cors: [],
-      }).route({
+      const app = createApp({}).route({
         path: '/users',
         method: 'get',
         validation: {},
diff --git a/__tests__/merge.ts b/__tests__/merge.ts
@@ -0,0 +1,10 @@
+import { deepMerge } from '../src/utils/merge';
+
+describe('deepMerge', () => {
+  it('should merge', () => {
+    const obj1 = { par1: -1, par2: { par2_1: -21, par2_5: -25 }, arr: [0, 1, 2] };
+    const obj2 = { par1: 1, par2: { par2_1: 21 }, par3: 3, arr: [3, 4, 5] };
+    const obj3 = deepMerge(obj1, obj2);
+    expect(obj3).toEqual({ par1: -1, par2: { par2_1: -21, par2_5: -25 }, par3: 3, arr: [0, 1, 2] });
+  });
+});
diff --git a/__tests__/router.test.ts b/__tests__/router.test.ts
@@ -8,11 +8,7 @@ declare module '../src' {
 
 describe('router', () => {
   it('should not accept multiple params in path segment', () => {
-    const app = createApp({
-      hostname: 'localhost',
-      port: 3000,
-      cors: [],
-    });
+    const app = createApp({});
 
     return expect(() =>
       app.route({
@@ -30,11 +26,7 @@ describe('router', () => {
   });
 
   it('should not accept regexes', () => {
-    const app = createApp({
-      hostname: 'localhost',
-      port: 3000,
-      cors: [],
-    });
+    const app = createApp({});
 
     return expect(() =>
       app.route({
diff --git a/examples/simple.ts b/examples/simple.ts
@@ -33,11 +33,7 @@ const loggerPlugin = createPlugin('logger', (app) => {
 });
 
 // app
-const app = createApp({
-  hostname: 'localhost',
-  port: 3000,
-  cors: [],
-});
+const app = createApp({});
 
 void app.plugin(loggerPlugin);
 void app.plugin(dbPlugin);
diff --git a/package.json b/package.json
@@ -35,8 +35,10 @@
   ],
   "dependencies": {
     "@typeofweb/schema": "0.8.0-5",
+    "@types/cors": "2.8.10",
     "@types/express": "4.17.12",
     "@types/supertest": "2.0.11",
+    "cors": "2.8.5",
     "express": "4.17.1",
     "stoppable": "1.1.0",
     "supertest": "6.1.3"
diff --git a/rollup.config.js b/rollup.config.js
@@ -90,7 +90,7 @@ LICENSE file in the root directory of this source tree.
 `.trim(),
       }),
     ],
-    external: ['url', 'body-parser', 'express', 'stoppable', '@typeofweb/schema', 'events', 'supertest'],
+    external: ['url', 'body-parser', 'express', 'stoppable', '@typeofweb/schema', 'events', 'supertest', 'cors', 'os'],
   },
 ];
 // eslint-disable-next-line import/no-default-export
diff --git a/src/modules/app.ts b/src/modules/app.ts
@@ -1,19 +1,32 @@
 import { URL } from 'url';
 
+import Cors from 'cors';
 import Supertest from 'supertest';
 
+import { deepMerge } from '../utils/merge';
 import { generateServerId } from '../utils/uniqueId';
 
 import { createEventBus } from './events';
 import { initApp, listenExpressServer } from './http';
 import { initRouter, validateRoute } from './router';
 
-import type { DeepWritable } from '../utils/types';
+import type { DeepPartial, DeepWritable } from '../utils/types';
 import type { TypeOfWebServerMeta } from './augment';
 import type { TypeOfWebPluginInternal } from './plugins';
 import type { AppOptions, TypeOfWebApp, TypeOfWebServer } from './shared';
 
-export function createApp(options: AppOptions): TypeOfWebApp {
+const defaultAppOptions: AppOptions = {
+  hostname: 'localhost',
+  port: 3000,
+  cors: {
+    origin: true,
+    credentials: true,
+  },
+};
+
+export function createApp(opts: DeepPartial<AppOptions>): TypeOfWebApp {
+  const options = deepMerge(opts, defaultAppOptions);
+
   const server: DeepWritable<TypeOfWebServer> = {
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- these properties are supposed to be added by the plugins inside `async start()`
     plugins: {} as TypeOfWebServer['plugins'],
@@ -59,13 +72,22 @@ export function createApp(options: AppOptions): TypeOfWebApp {
       return;
     }
 
+    if (options.cors) {
+      app._rawExpressApp.use(
+        Cors({
+          origin: options.cors.origin,
+          credentials: options.cors.credentials,
+        }),
+      );
+    }
+
     await initServerPlugins();
 
     app._rawExpressRouter = initRouter({ server, routes, plugins });
     app._rawExpressApp.use(app._rawExpressRouter);
 
-    server.events.emit(':server', server);
     mutableIsInitialized = true;
+    server.events.emit(':server', server);
   }
 
   const app: DeepWritable<TypeOfWebApp> = {
@@ -95,6 +117,7 @@ export function createApp(options: AppOptions): TypeOfWebApp {
       if (injection.payload) {
         mutableTest = mutableTest.send(injection.payload);
       }
+
       if (injection.headers) {
         mutableTest = Object.entries(injection.headers).reduce(
           (acc, [header, value]) => acc.set(header, value),
diff --git a/src/modules/shared.ts b/src/modules/shared.ts
@@ -12,9 +12,14 @@ import type * as Superagent from 'superagent';
 import type { URL } from 'url';
 
 export interface AppOptions {
-  readonly hostname: 'localhost';
-  readonly port: 3000;
-  readonly cors: readonly [];
+  readonly hostname: string;
+  readonly port: number;
+  readonly cors:
+    | {
+        readonly origin: true | string;
+        readonly credentials: boolean;
+      }
+    | false;
 }
 
 export interface TypeOfWebRequest<
diff --git a/src/utils/merge.ts b/src/utils/merge.ts
@@ -0,0 +1,16 @@
+/* eslint-disable @typescript-eslint/consistent-type-assertions -- :| */
+export const deepMerge = <T extends object, O extends object>(target: T, obj: O): T & O =>
+  (Object.keys(obj) as unknown as readonly (keyof O)[]).reduce(
+    (acc, key) => {
+      const val = obj[key];
+      return {
+        ...acc,
+        [key]:
+          typeof val === 'object' && !Array.isArray(val) && val
+            ? deepMerge(val as unknown as object, acc[key] ?? {})
+            : val,
+      };
+    },
+    { ...target } as T & O,
+  );
+/* eslint-enable @typescript-eslint/consistent-type-assertions */
diff --git a/src/utils/types.ts b/src/utils/types.ts
@@ -1,6 +1,10 @@
 import type { SomeSchema } from '@typeofweb/schema';
 
-type AnyObject = Record<keyof any, unknown>;
+export type AnyObject = Record<keyof any, unknown>;
+
+export type DeepPartial<T> = {
+  readonly [P in keyof T]?: T[P] extends AnyObject ? DeepPartial<T[P]> : T[P];
+};
 
 export type Pretty<X> = X extends AnyObject | readonly unknown[]
   ? {
@@ -32,3 +36,5 @@ interface SchemaJsonRecord {
 }
 export interface SchemaJsonArray extends ReadonlyArray<SchemaJson> {}
 export type SchemaJson = SomeSchema<JsonPrimitive | SchemaJsonRecord | SchemaJsonArray>;
+
+export type Nominal<T, K extends string> = T & { readonly __tag: K };
diff --git a/src/utils/uniqueId.ts b/src/utils/uniqueId.ts
@@ -1,10 +1,11 @@
 import Os from 'os';
 
-export const ID_SEPARATOR = '|' as const;
+import type { Nominal } from './types';
+
 const MAX_NUM = 2 ** 24;
 
-export type ServerId = string & { readonly __tag: 'ServerId' };
-export type RequestId = string & { readonly __tag: 'RequestId' };
+export type ServerId = Nominal<string, 'ServerId'>;
+export type RequestId = Nominal<string, 'RequestId'>;
 
 export const uniqueCounter = (() => {
   let mutableNum = Math.floor(Math.random() * MAX_NUM);
diff --git a/yarn.lock b/yarn.lock
