@gasket/plugin-fastify 0.0.0-canary-20250922152503

package/EXAMPLES.md

@@ -0,0 +1,144 @@
+# @gasket/plugin-fastify Examples
+
+This document provides working examples for all exported interfaces from `@gasket/plugin-fastify`.
+
+## Plugin Installation and Configuration
+
+### Basic Plugin Setup
+
+```js
+// gasket.js
+import { makeGasket } from '@gasket/core';
+import pluginFastify from '@gasket/plugin-fastify';
+
+export default makeGasket({
+  plugins: [
+    pluginFastify
+  ]
+});
+```
+
+### Plugin Configuration
+
+```js
+// gasket.js
+export default makeGasket({
+  plugins: [
+    pluginFastify
+  ],
+  fastify: {
+    compression: true,
+    trustProxy: true,
+    disableRequestLogging: false
+  }
+});
+```
+
+## Lifecycle Hooks
+
+### `fastify` Lifecycle Hook
+
+Access and modify the Fastify instance:
+
+```js
+// Example plugin or lifecycle file
+export default {
+  name: 'my-fastify-plugin',
+  hooks: {
+    fastify: async function (gasket, app) {
+      // Register plugins
+      app.register(require('@fastify/cors'), {
+        origin: true
+      });
+
+      // Add hooks
+      app.addHook('preHandler', async (request, reply) => {
+        console.log('Processing request:', request.url);
+      });
+
+      // Add custom decorators
+      app.decorate('customMethod', function() {
+        return 'custom value';
+      });
+
+      // Add routes
+      app.get('/hello', async (request, reply) => {
+        return { hello: 'world' };
+      });
+    }
+  }
+};
+```
+
+### `errorMiddleware` Lifecycle Hook
+
+Add Express-style error handling middleware:
+
+```js
+// Example plugin
+export default {
+  name: 'my-error-handler',
+  hooks: {
+    errorMiddleware: function (gasket) {
+      return (error, req, res, next) => {
+        gasket.logger.error('Request error:', error);
+
+        // Handle different error types
+        if (error.statusCode) {
+          res.status(error.statusCode);
+        } else {
+          res.status(500);
+        }
+
+        res.send({
+          error: 'Internal Server Error',
+          message: error.message
+        });
+      };
+    }
+  }
+};
+```
+
+## Configuration Examples
+
+### Route Plugin Example
+
+```js
+// plugins/routes-plugin.js
+export default {
+  name: 'routes-plugin',
+  hooks: {
+    fastify: async function (gasket, app) {
+      // API routes
+      app.get('/api/health', async (request, reply) => {
+        return {
+          status: 'healthy',
+          timestamp: new Date().toISOString(),
+          version: process.env.npm_package_version
+        };
+      });
+
+      app.get('/api/config', async (request, reply) => {
+        return {
+          environment: gasket.config.env,
+          features: gasket.config.features || {}
+        };
+      });
+
+      // Protected route example
+      app.get('/api/protected', {
+        preHandler: async (request, reply) => {
+          const auth = request.headers.authorization;
+          if (!auth || !auth.startsWith('Bearer ')) {
+            reply.code(401).send({ error: 'Unauthorized' });
+            return;
+          }
+        }
+      }, async (request, reply) => {
+        return { message: 'Protected data' };
+      });
+    }
+  }
+};
+```

package/LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 GoDaddy Operating Company, LLC.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,125 @@
+# @gasket/plugin-fastify
+
+Adds Fastify to your application.
+
+## Installation
+
+#### New apps
+
+```
+npm i @gasket/plugin-fastify
+```
+
+Update your `gasket` file plugin configuration:
+
+```diff
+// gasket.js
+
++ import pluginFastify from '@gasket/plugin-fastify';
+
+export default makeGasket({
+  plugins: [
++   pluginFastify
+  ]
+});
+```
+
+## Configuration
+
+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.
+- `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
+export default makeGasket({
+  plugins: [
+    pluginFastify
+  ],
+  fastify: {
+    compression: false,
+    excludedRoutesRegex: /^(?!\/_next\/)/,
+    trustProxy: true
+  }
+});
+```
+
+### Route Definition
+
+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
+// plugins/routes-plugin.js
+export default {
+  name: 'routes-plugin',
+  hooks: {
+    fastify: async function (gasket, app) {
+      app.get('/hello', (req, res) => {
+        res.send('Hello World!');
+      });
+    }
+  }
+};
+```
+
+## Lifecycles
+
+### fastify
+
+Executed **after** the `middleware` event for when you need full control over
+the `fastify` instance.
+
+```js
+export default {
+  name: 'sample-plugin',
+  hooks: {
+    /**
+    * Update Fastify app instance
+    *
+    * @param {Gasket} gasket The Gasket API
+    * @param {Fastify} fastify Fastify app instance
+    * @returns {function|function[]} middleware(s)
+    */
+    fastify: async function (gasket, fastify) {
+    }
+  }
+};
+```
+
+### errorMiddleware
+
+Executed after the `fastify` event. All middleware functions returned from this
+hook will be applied to Fastify.
+
+```js
+export default {
+  name: 'sample-plugin',
+  hooks: {
+    /**
+    * Add Fastify error middlewares
+    *
+    * @param {Gasket} gasket The Gasket API
+    * @returns {function|function[]} error middleware(s)
+    */
+    errorMiddleware: function (gasket) {
+    }
+  }
+};
+```
+
+## How it works
+
+This plugins hooks the [createServers] lifecycles from [@gasket/plugin-https].
+
+## License
+
+[MIT](./LICENSE.md)
+
+<!-- LINKS -->
+
+[@gasket/plugin-https]:/packages/gasket-plugin-https/README.md
+[createServers]:/packages/gasket-plugin-https/README.md#createservers

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/generator/vitest/test/index.test.js

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

package/generator/vitest/test/index.test.ts

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

package/lib/actions.js

@@ -0,0 +1,17 @@
+const { getAppInstance } = require('./utils.js');
+
+const actions = {
+  /**
+   * @deprecated
+   * @param {import('@gasket/core').Gasket} gasket - Gasket instance
+   * @returns {import('fastify').FastifyInstance} - Fastify instance
+   */
+  getFastifyApp(gasket) {
+    gasket.logger.warn(
+      `DEPRECATED \`getFastifyApp\` action will not be support in future major release.`
+    );
+    return getAppInstance(gasket);
+  }
+};
+
+module.exports = actions;

package/lib/create-servers.js

@@ -0,0 +1,32 @@
+/// <reference types="@gasket/plugin-https" />
+/// <reference types="@gasket/plugin-logger" />
+
+const { getAppInstance } = require('./utils.js');
+/**
+ * Create the Fastify instance and setup the lifecycle hooks.
+ * Fastify is compatible with express middleware out of the box, so we can
+ * use the same middleware lifecycles.
+ * @type {import('@gasket/core').HookHandler<'createServers'>}
+ */
+module.exports = async function createServers(gasket, serverOpts) {
+  /** Cast to Fastify + Express hybrid because Gasket adds `.use()` via @fastify/express plugin */
+  const app = /** @type {import('fastify').FastifyInstance & { use: Function }} */ (getAppInstance(gasket));
+
+  // allow consuming apps to directly append options to their server
+  await gasket.exec('fastify', app);
+
+  const postRenderingStacks = (await gasket.exec('errorMiddleware')).filter(Boolean);
+  postRenderingStacks.forEach((stack) => {
+    /** @type {import('connect').NextHandleFunction} */
+    const middleware = stack;
+    app.use(middleware);
+  });
+
+  return {
+    ...serverOpts,
+    handler: async function handler(...args) {
+      await app.ready();
+      app.server.emit('request', ...args);
+    }
+  };
+};

package/lib/create.js

@@ -0,0 +1,56 @@
+/// <reference types="@gasket/core" />
+/// <reference types="create-gasket-app" />
+
+const { name, version, devDependencies } = require('../package.json');
+
+const createTestFiles = ({ files, generatorDir, testPlugins, globIgnore }) => {
+  if (!testPlugins || testPlugins.length === 0) return;
+  const unit = ['jest', 'mocha', 'vitest'];
+  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

@@ -0,0 +1,67 @@
+import type { MaybeAsync, MaybeMultiple, Plugin } from '@gasket/core';
+import type { Logger } from '@gasket/plugin-logger';
+import type {
+  FastifyInstance,
+  FastifyRequest,
+  FastifyReply,
+  FastifyServerOptions,
+  FastifyBaseLogger,
+  FastifyTypeProviderDefault,
+  RawServerDefault
+} from 'fastify';
+import type { IncomingMessage, ServerResponse } from 'http';
+
+export interface FastifyConfig {
+  /** Enable compression */
+  compression?: boolean;
+  /** Trust proxy configuration */
+  trustProxy?: FastifyServerOptions['trustProxy'];
+  /** Fastify request logging per route */
+  disableRequestLogging?: boolean;
+}
+
+export type FastifyOptions = FastifyServerOptions & {
+  https?: any,
+  http2?: boolean | object
+}
+
+declare module '@gasket/core' {
+  export interface GasketActions {
+    /** @deprecated */
+    getFastifyApp(): FastifyInstance<RawServerDefault, IncomingMessage, ServerResponse<IncomingMessage>, FastifyBaseLogger, FastifyTypeProviderDefault>;
+  }
+
+  export interface GasketConfig {
+    fastify?: FastifyConfig
+  }
+
+
+  /** Error handler function type */
+  type ErrorHandler = (
+    error: Error,
+    req: FastifyRequest,
+    res: FastifyReply,
+    next: (error?: Error) => void
+  ) => void;
+
+  export interface HookExecTypes {
+    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;
+  }
+}
+
+declare const plugin: Plugin;
+
+export default plugin;

package/lib/index.js

@@ -0,0 +1,74 @@
+/// <reference types="@gasket/core" />
+/// <reference types="@gasket/plugin-metadata" />
+
+const { name, version, description } = require('../package.json');
+const create = require('./create');
+const createServers = require('./create-servers');
+const actions = require('./actions');
+
+/** @type {import('@gasket/core').Plugin} */
+const plugin = {
+  name,
+  version,
+  description,
+  actions,
+  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: 'fastify',
+            method: 'exec',
+            description: 'Modify the Fastify instance to for adding endpoints',
+            link: 'README.md#express',
+            parent: 'createServers',
+            after: 'middleware'
+          },
+          {
+            name: 'errorMiddleware',
+            method: 'exec',
+            description:
+              'Add Express style middleware for handling errors with Fastify',
+            link: 'README.md#errorMiddleware',
+            parent: 'createServers',
+            after: 'express'
+          }
+        ],
+        configurations: [
+          {
+            name: 'fastify',
+            link: 'README.md#configuration',
+            description: 'Fastify configuration object',
+            type: 'object'
+          },
+          {
+            name: 'fastify.compression',
+            link: 'README.md#configuration',
+            description: 'Automatic compression',
+            type: 'boolean',
+            default: true
+          },
+          {
+            name: 'fastify.excludedRoutesRegex',
+            link: 'README.md#configuration',
+            description: 'Routes to be excluded based on a regex',
+            type: 'RegExp'
+          }
+        ]
+      };
+    }
+  }
+};
+
+module.exports = plugin;

package/lib/utils.js

@@ -0,0 +1,50 @@
+// @ts-nocheck
+
+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('@gasket/plugin-fastify').alignLogger}
+ */
+function alignLogger(logger) {
+  const fastifyLogger = logger;
+  ['fatal', 'trace'].map(level => {
+    if (!logger[level]) {
+      fastifyLogger[level] = logger[fallbackMap[level]];
+    }
+  });
+
+  return fastifyLogger;
+}
+
+let instance = null;
+
+/**
+ * Get the Fastify instance.
+ * @param {import('@gasket/core').Gasket} gasket - Gasket instance
+ * @returns {import('fastify').FastifyInstance} - Fastify instance
+ */
+function getAppInstance(gasket) {
+  if (!instance) {
+    const fastify = require('fastify');
+    const { fastify: fastifyConfig = {}, http2, https } = gasket.config;
+    const { trustProxy = false, disableRequestLogging = true } = fastifyConfig;
+    const fastifyLogger = alignLogger(gasket.logger);
+
+    instance = fastify({ logger: fastifyLogger, trustProxy, https, http2, disableRequestLogging });
+  }
+
+  return instance;
+}
+
+module.exports = {
+  alignLogger,
+  getAppInstance,
+  testClearAppInstance: () => {
+    instance = null;
+  }
+};

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@gasket/plugin-fastify",
+  "version": "0.0.0-canary-20250922152503",
+  "description": "Adds fastify support to your application",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "files": [
+    "generator",
+    "lib",
+    "EXAMPLES.md"
+  ],
+  "repository": "godaddy/gasket.git",
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "fastify",
+    "gasket",
+    "plugin"
+  ],
+  "author": "GoDaddy Operating Company, LLC",
+  "license": "MIT",
+  "bugs": "https://github.com/godaddy/gasket/issues",
+  "homepage": "https://github.com/godaddy/gasket/tree/main/packages/gasket-plugin-fastify",
+  "dependencies": {
+    "@fastify/express": "^3.0.0",
+    "fastify": "^4.29.1"
+  },
+  "devDependencies": {
+    "@types/connect": "^3.4.38",
+    "fastify": "^4.29.1",
+    "jest": "^29.7.0",
+    "@gasket/core": "^0.0.0-canary-20250922152503",
+    "@gasket/plugin-https": "^0.0.0-canary-20250922152503",
+    "@gasket/plugin-logger": "^0.0.0-canary-20250922152503",
+    "create-gasket-app": "^0.0.0-canary-20250922152503",
+    "@gasket/plugin-metadata": "^0.0.0-canary-20250922152503"
+  },
+  "peerDependencies": {
+    "fastify": "^4.29.1"
+  },
+  "jest": {
+    "rootDir": "test"
+  },
+  "scripts": {
+    "lint": "eslint .",
+    "lint:fix": "pnpm run lint --fix",
+    "posttest": "pnpm run lint && pnpm run typecheck",
+    "test": "cross-env NODE_OPTIONS='--unhandled-rejections=strict' jest",
+    "test:coverage": "jest --coverage",
+    "test:watch": "jest --watch",
+    "typecheck": "tsc",
+    "typecheck:watch": "tsc --watch"
+  }
+}