@gasket/plugin-fastify 7.2.0-canary.20 → 7.2.0

package/README.md

@@ -6,26 +6,22 @@ Adds Fastify to your application.
 
 #### New apps
 
-```
-gasket create <app-name> --plugins @gasket/plugin-fastify
-```
-
-#### Existing apps
-
 ```
 npm i @gasket/plugin-fastify
 ```
 
-Modify `plugins` section of your `gasket.config.js`:
+Update your `gasket` file plugin configuration:
 
 ```diff
-module.exports = {
-  plugins: {
-    add: [
-+      '@gasket/plugin-fastify'
-    ]
-  }
-}
+// gasket.js
+
++ import pluginFastify from '@gasket/plugin-fastify';
+
+export default makeGasket({
+  plugins: [
++   pluginFastify
+  ]
+});
 ```
 
 ## Configuration
@@ -34,72 +30,44 @@ All the configurations for the plugin are added under `fastify` in the config:
 
 - `compression`: true by default. Can be set to false if applying compression
   differently.
-- `excludedRoutesRegex`: Routes to be excluded based on a regex
 - `trustProxy`: Enable trust proxy option, [see Fastify documentation for possible values](https://fastify.dev/docs/latest/Reference/Server/#trustproxy)
+- `disableRequestLogging`: Turn off request logging, true by default
 
 #### Example configuration
 
 ```js
-module.exports = {
-  plugins: {
-    add: ['@gasket/fastify']
-  },
+export default makeGasket({
+  plugins: [
+    pluginFastify
+  ],
   fastify: {
     compression: false,
+    routes: 'api/*.js',
     excludedRoutesRegex: /^(?!\/_next\/)/,
     trustProxy: true
   }
-}
+});
 ```
 
-### Middleware paths
+### Route Definition
 
-The `gasket.config.js` can contain a `middleware` property, which is an array of
-objects that map plugins to route or path patterns, allowing apps to tune which
-middleware are triggered for which requests.
+Routes can be defined in a in-app plugin in the `plugins` directory. The plugin will hook the `fastify` lifecycle to add the routes to the fastify app.
 
 ```js
-  middleware: [
-    {
-      plugin:'gasket-plugin-example', // Name of the Gasket plugin
-      paths: ['/api']
-    },
-    {
-      plugin:'@some/gasket-plugin-example',
-      paths: [/\/default/]
-    },
-    {
-      plugin: '@another/gasket-plugin-example',
-      paths: ['/proxy', /\/home/]
-    }
-  ]
-```
-
-## Lifecycles
-
-### middleware
-
-Executed when the `fastify` server has been created, it will apply all returned
-functions as middleware.
-
-```js
-module.exports = {
+// plugins/routes-plugin.js
+export default {
+  name: 'routes-plugin',
   hooks: {
-    /**
-    * Add Fastify middleware
-    *
-    * @param {Gasket} gasket The Gasket API
-    * @param {Fastify} app - Fastify app instance
-    * @returns {function|function[]} middleware(s)
-    */
-    middleware: function (gasket, app) {
-      return require('x-xss-protection')();
+    fastify: async function (gasket, app) {
+      app.get('/hello', (req, res) => {
+        res.send('Hello World!');
+      });
     }
   }
-}
+};
 ```
 
-You may also return an `Array` to inject more than one middleware.
+## Lifecycles
 
 ### fastify
 
@@ -107,7 +75,8 @@ Executed **after** the `middleware` event for when you need full control over
 the `fastify` instance.
 
 ```js
-module.exports = {
+export default {
+  name: 'sample-plugin',
   hooks: {
     /**
     * Update Fastify app instance
@@ -119,7 +88,7 @@ module.exports = {
     fastify: async function (gasket, fastify) {
     }
   }
-}
+};
 ```
 
 ### errorMiddleware
@@ -128,7 +97,8 @@ Executed after the `fastify` event. All middleware functions returned from this
 hook will be applied to Fastify.
 
 ```js
-module.exports = {
+export default {
+  name: 'sample-plugin',
   hooks: {
     /**
     * Add Fastify error middlewares
@@ -139,7 +109,7 @@ module.exports = {
     errorMiddleware: function (gasket) {
     }
   }
-}
+};
 ```
 
 ## How it works

package/generator/app/plugins/README.md

@@ -0,0 +1,11 @@
+# Local Plugins
+
+### Routes plugin
+
+A local plugin is used to define Fastify routes. The plugin hooks the `fastify` lifecycle and mutates the Fastify app.
+
+The following routes are available:
+
+```javascript
+GET /default
+```

package/generator/app/plugins/routes-plugin.js

@@ -0,0 +1,30 @@
+export const defaultHandler = async (req, res) => {
+  if (res.statusCode === 200) {
+    res.send({ message: 'Welcome to your default route...' });
+  }
+};
+
+export default {
+  name: 'routes-plugin',
+  hooks: {
+    fastify(gasket, app) {
+      {{#if useSwagger }}
+      /**
+      * @swagger
+      *
+      * /default:
+      *   get:
+      *     summary: "Get default route"
+      *     produces:
+      *       - "application/json"
+      *     responses:
+      *       "200":
+      *         description: "Returns welcome message."
+      *         content:
+      *           application/json
+      */
+      {{/if }}
+      app.get('/default', defaultHandler);
+    }
+  }
+}

package/generator/app/plugins/routes-plugin.ts

@@ -0,0 +1,29 @@
+export const defaultHandler = async (req, res) => {
+  if (res.statusCode === 200) {
+    res.send({ message: 'Welcome to your default route...' });
+  }
+};
+export default {
+  name: 'routes-plugin',
+  hooks: {
+    fastify(gasket, app) {
+      {{#if useSwagger }}
+      /**
+      * @swagger
+      *
+      * /default:
+      *   get:
+      *     summary: "Get default route"
+      *     produces:
+      *       - "application/json"
+      *     responses:
+      *       "200":
+      *         description: "Returns welcome message."
+      *         content:
+      *           application/json
+      */
+      {{/if }}
+      app.get('/default', defaultHandler);
+    }
+  }
+}

package/generator/jest/jest.config.js

@@ -0,0 +1,21 @@
+{{#if typescript}}
+const config = {
+  preset: 'ts-jest/presets/default-esm',
+  testEnvironment: 'node',
+  injectGlobals: true,
+  moduleDirectories: ['node_modules', '<rootDir>'],
+  moduleNameMapper: {
+    '^(\\.{1,2}/.*)\\.js$': '$1'
+  },
+  transform: {
+    '^.+.ts$': ['ts-jest', { useESM: true }]
+  }
+};
+
+export default config;
+{{else}}
+export default {
+  testEnvironment: 'node',
+  injectGlobals: true
+};
+{{/if}}

package/generator/jest/test/index.test.js

@@ -0,0 +1,20 @@
+import { jest } from '@jest/globals';
+import { defaultHandler } from '../plugins/routes-plugin.js';
+
+describe('Routes', () => {
+  let mockRequest, mockResponse;
+  beforeEach(() => {
+    mockRequest = {};
+    mockResponse = {
+      statusCode: 200,
+      send: jest.fn()
+    };
+  });
+
+  it('defaultHandler should use expeced message', async () => {
+    await defaultHandler(mockRequest, mockResponse);
+    expect(mockResponse.send).toHaveBeenCalledWith({
+      message: 'Welcome to your default route...'
+    });
+  });
+});

package/generator/jest/test/index.test.ts

@@ -0,0 +1,26 @@
+import {
+  jest,
+  describe,
+  beforeEach,
+  it,
+  expect
+} from '@jest/globals';
+import { defaultHandler } from '../plugins/routes-plugin.js';
+
+describe('Routes', () => {
+  let mockRequest, mockResponse;
+  beforeEach(() => {
+    mockRequest = {};
+    mockResponse = {
+      statusCode: 200,
+      send: jest.fn()
+    };
+  });
+
+  it('defaultHandler should use expeced message', async () => {
+    await defaultHandler(mockRequest, mockResponse);
+    expect(mockResponse.send).toHaveBeenCalledWith({
+      message: 'Welcome to your default route...'
+    });
+  });
+});

package/generator/mocha/test/index.test.js

@@ -0,0 +1,23 @@
+import { expect } from 'chai';
+import sinon from 'sinon';
+import { defaultHandler } from '../plugins/routes-plugin.js';
+
+describe('Routes', () => {
+  let mockRequest, mockResponse, sendSpy;
+
+  beforeEach(() => {
+    mockRequest = {};
+    sendSpy = sinon.spy();
+    mockResponse = {
+      statusCode: 200,
+      send: sendSpy
+    };
+  });
+
+  it('defaultHandler should use expected message', async () => {
+    await defaultHandler(mockRequest, mockResponse);
+    expect(sendSpy.calledWith({
+      message: 'Welcome to your default route...'
+    })).to.be.true;
+  });
+});

package/generator/mocha/test/index.test.ts

@@ -0,0 +1,23 @@
+import { expect } from 'chai';
+import sinon from 'sinon';
+import { defaultHandler } from '../plugins/routes-plugin.js';
+
+describe('Routes', () => {
+  let mockRequest, mockResponse, sendSpy;
+
+  beforeEach(() => {
+    mockRequest = {};
+    sendSpy = sinon.spy();
+    mockResponse = {
+      statusCode: 200,
+      send: sendSpy
+    };
+  });
+
+  it('defaultHandler should use expected message', async () => {
+    await defaultHandler(mockRequest, mockResponse);
+    expect(sendSpy.calledWith({
+      message: 'Welcome to your default route...'
+    })).to.be.true;
+  });
+});

package/lib/create-servers.js

@@ -1,12 +1,6 @@
 /// <reference types="@gasket/plugin-https" />
 /// <reference types="@gasket/plugin-logger" />
 
-const fastify = require('fastify');
-const middie = require('middie');
-const cookieParser = require('cookie-parser');
-const compression = require('compression');
-const debug = require('diagnostics')('gasket:fastify');
-
 /**
  * Create the Fastify instance and setup the lifecycle hooks.
  * Fastify is compatible with express middleware out of the box, so we can
@@ -15,73 +9,21 @@ const debug = require('diagnostics')('gasket:fastify');
  */
 // eslint-disable-next-line max-statements
 module.exports = async function createServers(gasket, serverOpts) {
-  const { logger, config } = gasket;
-  const { middleware: middlewareConfig } = config;
-  const trustProxy = config.fastify?.trustProxy ?? false;
-  const excludedRoutesRegex =
-    config.fastify && config.fastify.excludedRoutesRegex;
-  // @ts-ignore
-  const app = fastify({ logger, trustProxy });
-
-  // Enable middleware for fastify@3
-  await app.register(middie);
-
-  // Add express-like `res.locals` object attaching data
-  app.use(function attachLocals(req, res, next) {
-    res.locals = {};
-    next();
-  });
-
-  if (excludedRoutesRegex) {
-    app.use(excludedRoutesRegex, cookieParser());
-  } else {
-    app.use(cookieParser());
-  }
-
-  const { compression: compressionConfig = true } = config.fastify || {};
-  if (compressionConfig) {
-    app.use(compression());
-  }
-
-  const middlewares = [];
+  const fastify = require('fastify');
+  const { alignLogger } = require('./utils');
+  const { fastify: fastifyConfig = {}, http2, https } = gasket.config;
+  const { trustProxy = false, disableRequestLogging = true } = fastifyConfig;
+  const fastifyLogger = alignLogger(gasket.logger);
 
-  await gasket.execApply('middleware', async (plugin, handler) => {
-    const middleware = await handler(app);
-    if (middleware) {
-      if (middlewareConfig) {
-        const pluginName = plugin && plugin.name ? plugin.name : '';
-        const mwConfig = middlewareConfig.find(
-          (mw) => mw.plugin === pluginName
-        );
-        if (mwConfig) {
-          middleware.paths = mwConfig.paths;
-          if (excludedRoutesRegex) {
-            middleware.paths.push(excludedRoutesRegex);
-          }
-        }
-      }
-      middlewares.push(middleware);
-    }
-  });
-
-  debug('applied %s middleware layers to fastify', middlewares.length);
-  middlewares.forEach((layer) => {
-    const { paths } = layer;
-    if (paths) {
-      app.use(paths, layer);
-    } else if (excludedRoutesRegex) {
-      app.use(excludedRoutesRegex, layer);
-    } else {
-      app.use(layer);
-    }
-  });
+  // @ts-ignore
+  const app = fastify({ logger: fastifyLogger, trustProxy, https, http2, disableRequestLogging });
 
   // allow consuming apps to directly append options to their server
+  // @ts-ignore
   await gasket.exec('fastify', app);
 
-  const postRenderingStacks = (await gasket.exec('errorMiddleware')).filter(
-    Boolean
-  );
+  const postRenderingStacks = (await gasket.exec('errorMiddleware')).filter(Boolean);
+  // @ts-ignore
   postRenderingStacks.forEach((stack) => app.use(stack));
 
   return {

package/lib/create.js

@@ -0,0 +1,62 @@
+/// <reference types="@gasket/core" />
+
+const { name, version, devDependencies } = require('../package.json');
+
+/**
+ * createTestFiles
+ * @property {Files} files - The Gasket Files API.
+ * @property {generatorDir} - The directory of the generator.
+ * @property {testPlugins} - Array of selected test plugins
+ * @property {globIgnore} - Extension pattern to ignore
+ */
+function createTestFiles({ files, generatorDir, testPlugins, globIgnore }) {
+  if (!testPlugins || testPlugins.length === 0) return;
+  const unit = ['jest', 'mocha'];
+  const integration = ['cypress'];
+  const frameworks = [...unit, ...integration];
+  const frameworksRegex = new RegExp(frameworks.join('|'));
+
+  testPlugins.forEach((testPlugin) => {
+    const match = frameworksRegex.exec(testPlugin);
+    if (match) {
+      const matchedFramework = match[0];
+      if (unit.includes(matchedFramework)) {
+        files.add(`${generatorDir}/${matchedFramework}/*`, `${generatorDir}/${matchedFramework}/**/${globIgnore}`);
+      } else {
+        files.add(`${generatorDir}/${matchedFramework}/*`, `${generatorDir}/${matchedFramework}/**/*`);
+      }
+    }
+  });
+}
+
+/**
+ * Add files & extend package.json for new apps.
+ * @type {import('@gasket/core').HookHandler<'create'>}
+ */
+module.exports = async function create(gasket, context) {
+  const {
+    files,
+    typescript,
+    apiApp,
+    addApiRoutes = true,
+    testPlugins,
+    pkg,
+    gasketConfig
+  } = context;
+  const generatorDir = `${__dirname}/../generator`;
+
+  gasketConfig.addPlugin('pluginFastify', name);
+
+  pkg.add('dependencies', {
+    [name]: `^${version}`,
+    fastify: devDependencies.fastify
+  });
+
+  if (apiApp && addApiRoutes) {
+    const globIgnore = typescript ? '!(*.js)' : '!(*.ts)';
+    files.add(`${generatorDir}/app/**/${globIgnore}`);
+    gasketConfig.addPlugin('pluginRoutes', './plugins/routes-plugin.js');
+
+    createTestFiles({ files, generatorDir, testPlugins, globIgnore });
+  }
+};

package/lib/index.d.ts

@@ -1,22 +1,36 @@
-import type { MaybeAsync, MaybeMultiple } from '@gasket/core';
+import type { MaybeAsync, MaybeMultiple, Plugin } from '@gasket/core';
+import { Logger } from '@gasket/plugin-logger';
 import type {
-  Fastify,
+  FastifyInstance,
   FastifyRequest,
   FastifyReply,
-  FastifyServerOptions
+  FastifyServerOptions,
+  FastifyBaseLogger,
+  FastifyTypeProviderDefault,
+  RawServerDefault
 } from 'fastify';
+import { IncomingMessage, ServerResponse } from 'http';
+
+export type AppRoutes = Array<MaybeAsync<(app: FastifyInstance) => void>>;
 
 declare module '@gasket/core' {
+  export interface GasketActions {
+    /** @deprecated */
+    getFastifyApp(): FastifyInstance<RawServerDefault, IncomingMessage, ServerResponse<IncomingMessage>, FastifyBaseLogger, FastifyTypeProviderDefault>;
+  }
+
   export interface GasketConfig {
     fastify?: {
       /** Enable compression */
       compression?: boolean;
-      /** Regular expression for excluded routes */
+      /** Filter for which request URLs invoke Gasket middleware */
+      middlewareInclusionRegex?: RegExp;
+      /** @deprecated */
       excludedRoutesRegex?: RegExp;
       /** Trust proxy configuration */
       trustProxy?: FastifyServerOptions['trustProxy'];
-      /** Glob pattern for source files setting up fastify routes */
-      routes?: string;
+      /** Fastify request logging per route */
+      disableRequestLogging?: boolean;
     };
     /** Middleware configuration */
     middleware?: {
@@ -43,23 +57,29 @@ declare module '@gasket/core' {
 
   export interface HookExecTypes {
     middleware(
-      fastify: Fastify
+      app: FastifyInstance<RawServerDefault, IncomingMessage, ServerResponse<IncomingMessage>, FastifyBaseLogger, FastifyTypeProviderDefault>
     ): MaybeAsync<MaybeMultiple<Handler> & { paths?: (string | RegExp)[] }>;
-    fastify(fastify: Fastify): MaybeAsync<void>;
+    fastify(app: FastifyInstance<RawServerDefault, IncomingMessage, ServerResponse<IncomingMessage>, FastifyBaseLogger, FastifyTypeProviderDefault>): MaybeAsync<void>;
     errorMiddleware(): MaybeAsync<MaybeMultiple<ErrorHandler>>;
   }
 }
 
+export function alignLogger(
+  logger: Logger
+): FastifyBaseLogger
+
 declare module 'create-gasket-app' {
   export interface CreateContext {
     /** Flag indicating if API app is enabled */
     apiApp?: boolean;
+    addApiRoutes?: boolean;
+    typescript?: boolean;
   }
 }
 
-export default {
+const plugin: Plugin = {
   name: '@gasket/plugin-fastify',
-  version: '',
-  description: '',
   hooks: {}
 };
+
+export = plugin;

package/lib/index.js

@@ -4,36 +4,47 @@
 const {
   name,
   version,
-  description,
-  peerDependencies
+  description
 } = require('../package.json');
+const create = require('./create');
 const createServers = require('./create-servers');
+const fastify = require('fastify');
+const { alignLogger } = require('./utils');
+
+let app;
 
 /** @type {import('@gasket/core').Plugin} */
 const plugin = {
   name,
   version,
   description,
-  hooks: {
-    create: async function create(gasket, context) {
-      const generatorDir = `${__dirname}/../generator`;
+  actions: {
+    /** @deprecated */
+    getFastifyApp(gasket) {
+      const { fastify: fastifyConfig = {}, http2, https } = gasket.config;
+      const { trustProxy = false, disableRequestLogging = true } = fastifyConfig;
+      const fastifyLogger = alignLogger(gasket.logger);
 
-      context.pkg.add('dependencies', {
-        fastify: peerDependencies.fastify
-      });
+      // @ts-ignore
+      app ??= fastify({ logger: fastifyLogger, trustProxy, https, http2, disableRequestLogging });
 
-      if ('apiApp' in context && context.apiApp) {
-        context.files.add(`${generatorDir}/**/*`);
-
-        context.gasketConfig.add('fastify', {
-          routes: './routes/*'
-        });
-      }
-    },
+      return app;
+    }
+  },
+  hooks: {
+    create,
     createServers,
     metadata(gasket, meta) {
       return {
         ...meta,
+        actions: [
+          {
+            name: 'getFastifyApp',
+            description: 'Get the Fastify app instance',
+            link: 'README.md#getFastifyApp',
+            deprecated: true
+          }
+        ],
         lifecycles: [
           {
             name: 'middleware',

package/lib/utils.js

@@ -0,0 +1,26 @@
+// @ts-nocheck
+/* eslint-disable no-console */
+const fallbackMap = {
+  fatal: 'error',
+  trace: 'debug'
+};
+
+/**
+ * A helper function to ensure that all the required log levels
+ * for a Fastify server are present.
+ * @type {import('./index').alignLogger}
+ */
+function alignLogger(logger) {
+  const fastifyLogger = logger;
+  ['fatal', 'trace'].map(level => {
+    if (!logger[level]) {
+      fastifyLogger[level] = logger[fallbackMap[level]];
+    }
+  });
+
+  return fastifyLogger;
+}
+
+module.exports = {
+  alignLogger
+};

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@gasket/plugin-fastify",
-  "version": "7.2.0-canary.20",
+  "version": "7.2.0",
   "description": "Adds fastify support to your application",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
   "files": [
+    "generator",
     "lib"
   ],
   "scripts": {
@@ -30,34 +31,28 @@
     "plugin"
   ],
   "author": "GoDaddy Operating Company, LLC",
-  "maintainers": [
-    "Sivan Mehta <smehta@godaddy.com>"
-  ],
   "license": "MIT",
   "bugs": {
     "url": "https://github.com/godaddy/gasket/issues"
   },
   "homepage": "https://github.com/godaddy/gasket/tree/main/packages/gasket-plugin-fastify",
   "dependencies": {
-    "compression": "^1.7.4",
-    "cookie-parser": "^1.4.6",
-    "diagnostics": "^2.0.2",
-    "middie": "^5.4.0"
+    "fastify": "^4.28.1"
   },
   "devDependencies": {
-    "@gasket/core": "^7.2.0-canary.20",
+    "@gasket/core": "^7.2.0",
     "cross-env": "^7.0.3",
     "eslint": "^8.56.0",
-    "eslint-config-godaddy": "^7.1.0",
-    "eslint-plugin-jest": "^27.6.3",
+    "eslint-config-godaddy": "^7.1.1",
+    "eslint-plugin-jest": "^28.6.0",
     "eslint-plugin-json": "^3.1.0",
-    "eslint-plugin-unicorn": "^44.0.0",
-    "fastify": "^3.3.0",
+    "eslint-plugin-unicorn": "^55.0.0",
+    "fastify": "^4.28.1",
     "jest": "^29.7.0",
     "typescript": "^5.4.5"
   },
   "peerDependencies": {
-    "fastify": "^3.0.0"
+    "fastify": "^4"
   },
   "eslintConfig": {
     "extends": [
@@ -76,5 +71,8 @@
   "eslintIgnore": [
     "generator"
   ],
-  "gitHead": "abdb788c7ff44f4c6db7a5885e96e2dd315273fc"
+  "jest": {
+    "rootDir": "test"
+  },
+  "gitHead": "8790fd065f4bcb853fc9a2deecf0833999f41443"
 }