feat(fastify): added cors options on module initialization

packages/fastify/src/fastify.module.ts

@@ -1,7 +1,8 @@
 import { Module, ModuleWithProviders } from '@rhtml/di';
-import fastify from 'fastify';
+import fastify, { FastifyInstance } from 'fastify';
 
 import { Fastify, FastifyModuleOptions } from './fastify.tokens';
+import { addSchema, corsHook, globalErrorHandler, pipe } from './helpers';
 
 @Module()
 export class FastifyModule {
@@ -14,21 +15,20 @@ export class FastifyModule {
       providers: [
         {
           provide: Fastify,
-          useFactory: async () => {
-            const instance = fastifyInstance(options);
+          useFactory: async (): Promise<FastifyInstance> => {
+            const instance = await fastifyInstance(options);
             const plugins = options.plugins || [];
             const schemas = options.schemas || [];
 
             for (const plugin of plugins) {
               await instance.register(plugin.module, plugin.options);
             }
-            for (const schema of schemas) {
-              instance.addSchema(schema);
-            }
-            if (options.globalErrorHandler) {
-              instance.setErrorHandler(options.globalErrorHandler(instance));
-            }
-            return instance;
+
+            return pipe(
+              addSchema(schemas),
+              globalErrorHandler(options.globalErrorHandler),
+              corsHook(options.cors)
+            )(instance);
           },
         },
       ],

packages/fastify/src/fastify.tokens.ts

@@ -10,21 +10,26 @@ import {
   FastifySchema,
 } from 'fastify';
 
+import { CorsOptions } from './helpers/hooks/cors.hook';
+
 export const Fastify = new InjectionToken<FastifyInstance>();
 
 export interface FastifyPlugin {
   module: FastifyPluginCallback;
   options?: FastifyRegisterOptions<unknown>;
 }
 
+export type GlobalErrorHandler = (
+  instance: FastifyInstance
+) => (
+  error: FastifyError,
+  request: FastifyRequest,
+  reply: FastifyReply
+) => FastifyReply;
+
 export interface FastifyModuleOptions extends FastifyHttpOptions<never> {
   plugins: FastifyPlugin[];
   schemas: FastifySchema[];
-  globalErrorHandler: (
-    instance: FastifyInstance
-  ) => (
-    error: FastifyError,
-    request: FastifyRequest,
-    reply: FastifyReply
-  ) => FastifyReply;
+  globalErrorHandler: GlobalErrorHandler;
+  cors: CorsOptions;
 }

packages/fastify/src/helpers/hooks/add-schema.hook.ts

@@ -0,0 +1,13 @@
+import { Reader } from '@rhtml/di';
+import { FastifyInstance, FastifySchema } from 'fastify';
+
+export function addSchema(
+  schemas: FastifySchema[]
+): Reader<FastifyInstance, FastifyInstance> {
+  return (instance) => {
+    for (const schema of schemas) {
+      instance.addSchema(schema);
+    }
+    return instance;
+  };
+}

packages/fastify/src/helpers/hooks/cors.hook.ts

@@ -0,0 +1,32 @@
+import { Reader } from '@rhtml/di';
+import { FastifyInstance } from 'fastify';
+
+export interface AllowedType {
+  name: string;
+  methods: string[];
+}
+
+export interface CorsOptions {
+  allowedOrigins: AllowedType[];
+}
+
+export function corsHook(
+  { allowedOrigins = [] }: CorsOptions = { allowedOrigins: [] }
+): Reader<FastifyInstance, FastifyInstance> {
+  return (instance) => {
+    instance.addHook('preHandler', (req, res, done) => {
+      const hostname = allowedOrigins.find((v) => v.name === req.hostname);
+      if (hostname) {
+        res.header('Access-Control-Allow-Origin', hostname.name);
+        res.header('Access-Control-Allow-Headers', hostname.name);
+        res.header('Access-Control-Allow-Methods', hostname.methods);
+      }
+      const isPreflight = /options/i.test(req.method);
+      if (isPreflight) {
+        return res.send();
+      }
+      return done();
+    });
+    return instance;
+  };
+}

packages/fastify/src/helpers/hooks/global-error.hook.ts

@@ -0,0 +1,15 @@
+import { Reader } from '@rhtml/di';
+import { FastifyInstance } from 'fastify';
+
+import { GlobalErrorHandler } from '../../fastify.tokens';
+
+export function globalErrorHandler(
+  globalErrorHandler: GlobalErrorHandler
+): Reader<FastifyInstance, FastifyInstance> {
+  return (instance) => {
+    if (globalErrorHandler) {
+      instance.setErrorHandler(globalErrorHandler(instance));
+    }
+    return instance;
+  };
+}

packages/fastify/src/helpers/hooks/index.ts

@@ -0,0 +1,3 @@
+export * from './cors.hook';
+export * from './add-schema.hook';
+export * from './global-error.hook';

packages/fastify/src/helpers/index.ts

@@ -0,0 +1,2 @@
+export * from './hooks';
+export * from './pipe.helper';

packages/fastify/src/helpers/pipe.helper.ts

@@ -0,0 +1,4 @@
+export const pipe =
+  <T>(...fns: Array<(arg: T) => T>) =>
+  (value: T) =>
+    fns.reduce((acc, fn) => fn(acc), value);