@a_jackie_z/fastify 1.0.0

package/README.md

@@ -0,0 +1,492 @@
+# @a_jackie_z/fastify
+
+A collection of Fastify plugins and utilities for building robust web applications with built-in support for JWT authentication, rate limiting, Swagger documentation, and TypeBox validation.
+
+## Installation
+
+```bash
+npm install @a_jackie_z/fastify
+```
+
+## Quick Start
+
+### Basic Setup
+
+```typescript
+import { createFastify } from '@a_jackie_z/fastify'
+import { Type } from '@sinclair/typebox'
+
+const app = await createFastify()
+
+app.route({
+  method: 'GET',
+  url: '/hello',
+  schema: {
+    response: {
+      200: Type.Object({
+        message: Type.String(),
+      }),
+    },
+  },
+  handler: async () => {
+    return { message: 'Hello World!' }
+  },
+})
+
+await app.listen({ port: 3000 })
+```
+
+## Features
+
+- **JWT Authentication** - Built-in JWT support with global and route-level configuration
+- **Rate Limiting** - Flexible rate limiting at global and route levels
+- **Swagger Documentation** - Auto-generated API documentation with TypeBox schemas
+- **TypeBox Integration** - Type-safe request/response validation
+- **Logger Integration** - Uses `@a_jackie_z/logger` for consistent logging
+
+## Examples
+
+### 1. Complete Setup with All Features
+
+```typescript
+import { createFastify } from '@a_jackie_z/fastify'
+import { Type } from '@sinclair/typebox'
+
+const app = await createFastify({
+  // Rate limiting
+  rateLimit: {
+    global: {
+      max: 100,
+      timeWindow: '1 minute',
+    },
+  },
+  // JWT authentication
+  jwt: {
+    secret: 'your-secret-key',
+    sign: {
+      expiresIn: '1h',
+    },
+    global: true, // Require JWT for all routes by default
+  },
+  // Swagger documentation
+  swagger: {
+    title: 'My API',
+    version: '1.0.0',
+    description: 'API documentation',
+    routePrefix: '/docs',
+  },
+})
+
+await app.listen({ port: 3000 })
+```
+
+### 2. Authentication Flow
+
+#### Login Route (Public)
+
+```typescript
+app.route({
+  method: 'POST',
+  url: '/auth/login',
+  config: {
+    jwt: false, // Bypass JWT check for login
+  },
+  schema: {
+    body: Type.Object({
+      username: Type.String(),
+      password: Type.String(),
+    }),
+    response: {
+      200: Type.Object({
+        token: Type.String(),
+      }),
+      401: Type.Object({
+        error: Type.String(),
+      }),
+    },
+  },
+  handler: async (request, reply) => {
+    const { username, password } = request.body
+
+    // Validate credentials
+    if (username === 'admin' && password === 'secret') {
+      const token = app.jwt.sign({
+        username,
+        role: 'admin',
+        permissions: ['read', 'write', 'delete'],
+      })
+      return { token }
+    }
+
+    reply.status(401)
+    return { error: 'Invalid credentials' }
+  },
+})
+```
+
+#### Public Route
+
+```typescript
+app.route({
+  method: 'GET',
+  url: '/public',
+  config: {
+    jwt: false, // No authentication required
+  },
+  schema: {
+    response: {
+      200: Type.Object({
+        message: Type.String(),
+      }),
+    },
+  },
+  handler: async () => {
+    return { message: 'Public endpoint - no auth required' }
+  },
+})
+```
+
+#### Protected Route (Auto-Protected by Global JWT)
+
+```typescript
+app.route({
+  method: 'GET',
+  url: '/protected',
+  // No config needed - global JWT setting applies
+  schema: {
+    response: {
+      200: Type.Object({
+        message: Type.String(),
+        user: Type.Unknown(),
+      }),
+    },
+  },
+  handler: async (request) => {
+    return {
+      message: 'Protected data',
+      user: request.user, // JWT payload
+    }
+  },
+})
+```
+
+### 3. Role-Based Authorization
+
+```typescript
+app.route({
+  method: 'GET',
+  url: '/admin',
+  config: {
+    jwt: {
+      authorize: async (_request, _reply, user) => {
+        // Check if user has admin role
+        return user?.role === 'admin'
+      },
+    },
+  },
+  schema: {
+    response: {
+      200: Type.Object({
+        message: Type.String(),
+      }),
+      403: Type.Object({
+        error: Type.String(),
+        message: Type.String(),
+      }),
+    },
+  },
+  handler: async () => {
+    return { message: 'Admin-only content' }
+  },
+})
+```
+
+### 4. Permission-Based Authorization
+
+```typescript
+app.route({
+  method: 'DELETE',
+  url: '/operations/:id',
+  config: {
+    jwt: {
+      authorize: async (_request, _reply, user) => {
+        // Check if user has delete permission
+        return user?.permissions?.includes('delete') === true
+      },
+    },
+  },
+  schema: {
+    params: Type.Object({
+      id: Type.String(),
+    }),
+    response: {
+      200: Type.Object({
+        message: Type.String(),
+      }),
+    },
+  },
+  handler: async (request) => {
+    const { id } = request.params
+    return { message: `Operation ${id} deleted` }
+  },
+})
+```
+
+### 5. Custom Authorization Logic
+
+```typescript
+app.route({
+  method: 'POST',
+  url: '/custom-auth',
+  config: {
+    jwt: {
+      authorize: async (request, _reply, user) => {
+        // Custom logic: only allow specific users
+        if (user?.username === 'special-user') {
+          return true
+        }
+        // Check request headers
+        if (request.headers['x-custom-header'] === 'allowed') {
+          return true
+        }
+        return false
+      },
+    },
+  },
+  handler: async () => {
+    return { message: 'Custom authorization passed' }
+  },
+})
+```
+
+### 6. Rate Limiting
+
+#### Route-Specific Rate Limit
+
+```typescript
+app.route({
+  method: 'GET',
+  url: '/limited',
+  config: {
+    rateLimit: {
+      max: 5,
+      timeWindow: '1 minute',
+    },
+  },
+  handler: async () => {
+    return { message: 'Strict rate limiting applied' }
+  },
+})
+```
+
+#### Disable Rate Limit for Specific Route
+
+```typescript
+app.route({
+  method: 'GET',
+  url: '/unlimited',
+  config: {
+    rateLimit: false,
+  },
+  handler: async () => {
+    return { message: 'No rate limiting' }
+  },
+})
+```
+
+### 7. TypeBox Schema Validation
+
+```typescript
+app.route({
+  method: 'POST',
+  url: '/users',
+  schema: {
+    body: Type.Object({
+      name: Type.String({ minLength: 1, maxLength: 100 }),
+      email: Type.String({ format: 'email' }),
+      age: Type.Optional(Type.Number({ minimum: 0, maximum: 150 })),
+    }),
+    response: {
+      201: Type.Object({
+        id: Type.String(),
+        name: Type.String(),
+        email: Type.String(),
+      }),
+      400: Type.Object({
+        error: Type.String(),
+      }),
+    },
+  },
+  handler: async (request, reply) => {
+    const user = request.body
+    reply.status(201)
+    return {
+      id: 'generated-id',
+      ...user,
+    }
+  },
+})
+```
+
+## Configuration Options
+
+### `CreateFastifyOptions`
+
+```typescript
+interface CreateFastifyOptions {
+  rateLimit?: {
+    global?: RateLimitPluginOptions
+  }
+  jwt?: {
+    secret: string
+    sign?: FastifyJWTOptions['sign']
+    verify?: FastifyJWTOptions['verify']
+    global?: boolean // Enable JWT check globally for all routes
+  }
+  swagger?: {
+    title: string
+    version: string
+    description: string
+    routePrefix?: string // Default: '/documentation'
+  }
+}
+```
+
+### Route JWT Configuration
+
+```typescript
+interface JWTRouteConfig {
+  jwt?:
+    | boolean // true = require JWT, false = bypass JWT
+    | {
+        required?: boolean // Default: true if global enabled
+        authorize?: JWTAuthorizationHandler // Custom authorization logic
+      }
+}
+
+type JWTAuthorizationHandler = (
+  request: FastifyRequest,
+  reply: FastifyReply,
+  user: any
+) => Promise<boolean> | boolean
+```
+
+## Usage Patterns
+
+### Pattern 1: Global JWT with Selective Public Routes
+
+```typescript
+const app = await createFastify({
+  jwt: {
+    secret: 'your-secret',
+    global: true, // All routes require JWT by default
+  },
+})
+
+// Public routes explicitly bypass JWT
+app.route({
+  method: 'POST',
+  url: '/auth/login',
+  config: { jwt: false },
+  handler: async () => { /* ... */ },
+})
+
+// Protected routes don't need config
+app.route({
+  method: 'GET',
+  url: '/data',
+  handler: async () => { /* ... */ },
+})
+```
+
+### Pattern 2: Opt-In JWT Protection
+
+```typescript
+const app = await createFastify({
+  jwt: {
+    secret: 'your-secret',
+    global: false, // JWT not required by default
+  },
+})
+
+// Unprotected by default
+app.route({
+  method: 'GET',
+  url: '/public',
+  handler: async () => { /* ... */ },
+})
+
+// Explicitly require JWT
+app.route({
+  method: 'GET',
+  url: '/protected',
+  config: { jwt: true },
+  handler: async () => { /* ... */ },
+})
+```
+
+### Pattern 3: Multi-Tier Authorization
+
+```typescript
+const app = await createFastify({
+  jwt: {
+    secret: 'your-secret',
+    global: true,
+  },
+})
+
+// Tier 1: Any authenticated user
+app.route({
+  method: 'GET',
+  url: '/user/profile',
+  handler: async (request) => {
+    return request.user
+  },
+})
+
+// Tier 2: Admin users only
+app.route({
+  method: 'GET',
+  url: '/admin/users',
+  config: {
+    jwt: {
+      authorize: async (_req, _reply, user) => user?.role === 'admin',
+    },
+  },
+  handler: async () => { /* ... */ },
+})
+
+// Tier 3: Super admin with specific permission
+app.route({
+  method: 'DELETE',
+  url: '/admin/system',
+  config: {
+    jwt: {
+      authorize: async (_req, _reply, user) => 
+        user?.role === 'admin' && user?.permissions?.includes('system:delete'),
+    },
+  },
+  handler: async () => { /* ... */ },
+})
+```
+
+## Testing Your API
+
+1. Start your server
+2. Access Swagger documentation at `http://localhost:3000/docs`
+3. Test authentication:
+
+```bash
+# Login
+curl -X POST http://localhost:3000/auth/login \
+  -H "Content-Type: application/json" \
+  -d '{"username":"admin","password":"secret"}'
+
+# Use token
+curl http://localhost:3000/protected \
+  -H "Authorization: Bearer YOUR_TOKEN"
+```
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,49 @@
+import * as fastify from 'fastify';
+import { FastifyRequest, FastifyReply, FastifyServerOptions, FastifyInstance, RawServerDefault, FastifyBaseLogger, FastifyContextConfig, FastifyPluginCallback } from 'fastify';
+import { TypeBoxTypeProvider } from '@fastify/type-provider-typebox';
+import { RateLimitPluginOptions } from '@fastify/rate-limit';
+import { FastifyJWTOptions } from '@fastify/jwt';
+import { IncomingMessage, ServerResponse } from 'node:http';
+
+type JWTAuthorizationHandler = <TUser = unknown>(request: FastifyRequest, reply: FastifyReply, user: TUser) => Promise<boolean> | boolean;
+interface JWTRouteConfig {
+    jwt?: boolean | {
+        required?: boolean;
+        authorize?: JWTAuthorizationHandler;
+    };
+}
+declare module 'fastify' {
+    interface FastifyContextConfig {
+        jwt?: boolean | {
+            required?: boolean;
+            authorize?: JWTAuthorizationHandler;
+        };
+    }
+}
+interface CreateFastifyOptions {
+    logger?: FastifyServerOptions['loggerInstance'];
+    rateLimit?: {
+        global?: RateLimitPluginOptions;
+    };
+    jwt?: {
+        secret: string;
+        sign?: FastifyJWTOptions['sign'];
+        verify?: FastifyJWTOptions['verify'];
+        global?: boolean;
+    };
+    swagger?: {
+        title: string;
+        version: string;
+        description: string;
+        routePrefix?: string;
+    };
+}
+type FastifyServer = FastifyInstance<RawServerDefault, IncomingMessage, ServerResponse, FastifyBaseLogger, TypeBoxTypeProvider> & FastifyContextConfig;
+declare function createFastify(options?: CreateFastifyOptions): Promise<FastifyServer>;
+declare function runFastify(fastify: FastifyServer, host: string, port: number): Promise<void>;
+
+declare function createFastifyPlugin(cb: FastifyPluginCallback): FastifyPluginCallback;
+
+declare const healthPlugin: fastify.FastifyPluginCallback;
+
+export { type CreateFastifyOptions, type FastifyServer, type JWTAuthorizationHandler, type JWTRouteConfig, createFastify, createFastifyPlugin, healthPlugin, runFastify };

package/dist/index.js

@@ -0,0 +1,116 @@
+// lib/fastify.ts
+import Fastify from "fastify";
+import fastifyRateLimit from "@fastify/rate-limit";
+import fastifyJwt from "@fastify/jwt";
+import fastifySwagger from "@fastify/swagger";
+import fastifySwaggerUI from "@fastify/swagger-ui";
+async function createFastify(options) {
+  const fastifyOptions = {};
+  if (options?.logger) {
+    fastifyOptions.loggerInstance = options.logger;
+  }
+  const fastify = Fastify(fastifyOptions).withTypeProvider();
+  if (options?.swagger) {
+    await fastify.register(fastifySwagger, {
+      openapi: {
+        info: {
+          title: options.swagger.title,
+          version: options.swagger.version,
+          description: options.swagger.description
+        }
+      }
+    });
+    let routePrefix = options.swagger.routePrefix || "/docs/";
+    if (!routePrefix.startsWith("/")) {
+      routePrefix = "/" + routePrefix;
+    }
+    if (!routePrefix.endsWith("/")) {
+      routePrefix = routePrefix + "/";
+    }
+    await fastify.register(fastifySwaggerUI, { routePrefix });
+  }
+  if (options?.jwt) {
+    const jwtOptions = {
+      secret: options.jwt.secret
+    };
+    if (options.jwt.sign !== void 0) {
+      jwtOptions.sign = options.jwt.sign;
+    }
+    if (options.jwt.verify !== void 0) {
+      jwtOptions.verify = options.jwt.verify;
+    }
+    await fastify.register(fastifyJwt, jwtOptions);
+    if (options.jwt.global) {
+      fastify.addHook("onRequest", async (request, reply) => {
+        const routeConfig = request.routeOptions.config || {};
+        const jwtConfig = routeConfig.jwt;
+        if (jwtConfig === false) {
+          return;
+        }
+        const shouldVerify = jwtConfig === true || typeof jwtConfig === "object" && jwtConfig.required !== false || jwtConfig === void 0 && options?.jwt?.global === true;
+        if (shouldVerify) {
+          try {
+            await request.jwtVerify();
+            if (typeof jwtConfig === "object" && jwtConfig.authorize) {
+              const authorized = await jwtConfig.authorize(request, reply, request.user);
+              if (!authorized) {
+                reply.status(403).send({
+                  error: "Forbidden",
+                  message: "Authorization failed"
+                });
+                return;
+              }
+            }
+          } catch (err) {
+            reply.status(401).send({
+              error: "Unauthorized",
+              message: "Invalid or missing JWT token"
+            });
+          }
+        }
+      });
+    }
+  }
+  if (options?.rateLimit?.global) {
+    await fastify.register(fastifyRateLimit, {
+      global: true,
+      ...options.rateLimit.global
+    });
+  }
+  return fastify;
+}
+async function runFastify(fastify, host, port) {
+  try {
+    await fastify.listen({ host, port });
+  } catch (err) {
+    fastify.log.error(err);
+    process.exit(1);
+  }
+}
+
+// lib/plugin.ts
+function createFastifyPlugin(cb) {
+  return cb;
+}
+
+// lib/plugins/healthPlugin.ts
+var healthPlugin = createFastifyPlugin((app) => {
+  app.get("/v1/health", {
+    schema: {
+      tags: ["health"]
+    },
+    handler: async () => {
+      return {
+        status: 200,
+        message: "ok"
+      };
+    }
+  });
+});
+export {
+  createFastify,
+  createFastifyPlugin,
+  healthPlugin,
+  runFastify
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../lib/fastify.ts","../lib/plugin.ts","../lib/plugins/healthPlugin.ts"],"sourcesContent":["import Fastify, {\n  FastifyBaseLogger,\n  FastifyContextConfig,\n  FastifyInstance,\n  FastifyReply,\n  FastifyServerOptions,\n  RawServerDefault,\n} from 'fastify'\nimport type { FastifyRequest } from 'fastify'\nimport { TypeBoxTypeProvider } from '@fastify/type-provider-typebox'\nimport fastifyRateLimit, { RateLimitPluginOptions } from '@fastify/rate-limit'\nimport fastifyJwt, { FastifyJWTOptions } from '@fastify/jwt'\nimport fastifySwagger, { SwaggerOptions } from '@fastify/swagger'\nimport fastifySwaggerUI, { FastifySwaggerUiOptions } from '@fastify/swagger-ui'\nimport { IncomingMessage, ServerResponse } from 'node:http'\n\nexport type JWTAuthorizationHandler = <TUser = unknown>(\n  request: FastifyRequest,\n  reply: FastifyReply,\n  user: TUser\n) => Promise<boolean> | boolean\n\nexport interface JWTRouteConfig {\n  jwt?:\n    | boolean // true = require JWT, false = bypass JWT\n    | {\n        required?: boolean // Default: true if global enabled\n        authorize?: JWTAuthorizationHandler // Check JWT info before route processing\n      }\n}\n\n// Extend Fastify types to include custom config\ndeclare module 'fastify' {\n  interface FastifyContextConfig {\n    jwt?:\n      | boolean\n      | {\n          required?: boolean\n          authorize?: JWTAuthorizationHandler\n        }\n  }\n}\n\nexport interface CreateFastifyOptions {\n  logger?: FastifyServerOptions['loggerInstance'],\n  rateLimit?: {\n    global?: RateLimitPluginOptions\n  }\n  jwt?: {\n    secret: string\n    sign?: FastifyJWTOptions['sign']\n    verify?: FastifyJWTOptions['verify']\n    global?: boolean // Enable JWT check globally for all routes\n  }\n  swagger?: {\n    title: string\n    version: string\n    description: string\n    routePrefix?: string\n  }\n}\n\nexport type FastifyServer = FastifyInstance<\n  RawServerDefault,\n  IncomingMessage,\n  ServerResponse,\n  FastifyBaseLogger,\n  TypeBoxTypeProvider\n> & FastifyContextConfig\n\nexport async function createFastify(options?: CreateFastifyOptions): Promise<FastifyServer> {\n  const fastifyOptions: FastifyServerOptions = {}\n\n  if (options?.logger) {\n    fastifyOptions.loggerInstance = options.logger\n  }\n\n  const fastify = Fastify(fastifyOptions).withTypeProvider<TypeBoxTypeProvider>()\n\n  // Register Swagger first to capture all routes with TypeBox schemas\n  if (options?.swagger) {\n    await fastify.register(fastifySwagger, {\n      openapi: {\n        info: {\n          title: options.swagger.title,\n          version: options.swagger.version,\n          description: options.swagger.description,\n        },\n      },\n    } as SwaggerOptions)\n\n    let routePrefix = options.swagger.routePrefix || '/docs/'\n\n    if (!routePrefix.startsWith('/')) {\n      routePrefix = '/' + routePrefix\n    }\n\n    if (!routePrefix.endsWith('/')) {\n      routePrefix = routePrefix + '/'\n    }\n\n    await fastify.register(fastifySwaggerUI, { routePrefix } as FastifySwaggerUiOptions)\n  }\n\n  // Register JWT authentication\n  if (options?.jwt) {\n    const jwtOptions: FastifyJWTOptions = {\n      secret: options.jwt.secret,\n    }\n    if (options.jwt.sign !== undefined) {\n      jwtOptions.sign = options.jwt.sign\n    }\n    if (options.jwt.verify !== undefined) {\n      jwtOptions.verify = options.jwt.verify\n    }\n    await fastify.register(fastifyJwt, jwtOptions)\n\n    // Global JWT checking hook\n    if (options.jwt.global) {\n      fastify.addHook('onRequest', async (request, reply) => {\n        const routeConfig = (request.routeOptions.config as JWTRouteConfig) || {}\n        const jwtConfig = routeConfig.jwt\n\n        // Check if route explicitly bypasses JWT\n        if (jwtConfig === false) {\n          return\n        }\n\n        // Check if route explicitly requires JWT or uses global setting\n        const shouldVerify =\n          jwtConfig === true ||\n          (typeof jwtConfig === 'object' && jwtConfig.required !== false) ||\n          (jwtConfig === undefined && options?.jwt?.global === true)\n\n        if (shouldVerify) {\n          try {\n            await request.jwtVerify()\n\n            // Custom authorization - check JWT info before route processing\n            if (typeof jwtConfig === 'object' && jwtConfig.authorize) {\n              const authorized = await jwtConfig.authorize(request, reply, request.user)\n              if (!authorized) {\n                reply.status(403).send({\n                  error: 'Forbidden',\n                  message: 'Authorization failed',\n                })\n                return\n              }\n            }\n          } catch (err) {\n            reply.status(401).send({\n              error: 'Unauthorized',\n              message: 'Invalid or missing JWT token',\n            })\n          }\n        }\n      })\n    }\n  }\n\n  // Register Rate Limiting\n  if (options?.rateLimit?.global) {\n    await fastify.register(fastifyRateLimit, {\n      global: true,\n      ...options.rateLimit.global,\n    })\n  }\n\n  return fastify\n}\n\nexport async function runFastify(fastify: FastifyServer, host: string, port: number) {\n  try {\n    await fastify.listen({ host, port })\n  } catch (err) {\n    fastify.log.error(err)\n    process.exit(1)\n  }\n}\n","import { FastifyPluginCallback } from 'fastify'\n\nexport function createFastifyPlugin(cb: FastifyPluginCallback) {\n  return cb;\n}\n","import { createFastifyPlugin } from '../plugin.ts'\n\nexport const healthPlugin = createFastifyPlugin((app) => {\n  app.get('/v1/health', {\n    schema: {\n      tags: ['health'],\n    },\n    handler: async () => {\n      return {\n        status: 200,\n        message: 'ok',\n      }\n    },\n  })\n})\n"],"mappings":";AAAA,OAAO,aAOA;AAGP,OAAO,sBAAkD;AACzD,OAAO,gBAAuC;AAC9C,OAAO,oBAAwC;AAC/C,OAAO,sBAAmD;AAyD1D,eAAsB,cAAc,SAAwD;AAC1F,QAAM,iBAAuC,CAAC;AAE9C,MAAI,SAAS,QAAQ;AACnB,mBAAe,iBAAiB,QAAQ;AAAA,EAC1C;AAEA,QAAM,UAAU,QAAQ,cAAc,EAAE,iBAAsC;AAG9E,MAAI,SAAS,SAAS;AACpB,UAAM,QAAQ,SAAS,gBAAgB;AAAA,MACrC,SAAS;AAAA,QACP,MAAM;AAAA,UACJ,OAAO,QAAQ,QAAQ;AAAA,UACvB,SAAS,QAAQ,QAAQ;AAAA,UACzB,aAAa,QAAQ,QAAQ;AAAA,QAC/B;AAAA,MACF;AAAA,IACF,CAAmB;AAEnB,QAAI,cAAc,QAAQ,QAAQ,eAAe;AAEjD,QAAI,CAAC,YAAY,WAAW,GAAG,GAAG;AAChC,oBAAc,MAAM;AAAA,IACtB;AAEA,QAAI,CAAC,YAAY,SAAS,GAAG,GAAG;AAC9B,oBAAc,cAAc;AAAA,IAC9B;AAEA,UAAM,QAAQ,SAAS,kBAAkB,EAAE,YAAY,CAA4B;AAAA,EACrF;AAGA,MAAI,SAAS,KAAK;AAChB,UAAM,aAAgC;AAAA,MACpC,QAAQ,QAAQ,IAAI;AAAA,IACtB;AACA,QAAI,QAAQ,IAAI,SAAS,QAAW;AAClC,iBAAW,OAAO,QAAQ,IAAI;AAAA,IAChC;AACA,QAAI,QAAQ,IAAI,WAAW,QAAW;AACpC,iBAAW,SAAS,QAAQ,IAAI;AAAA,IAClC;AACA,UAAM,QAAQ,SAAS,YAAY,UAAU;AAG7C,QAAI,QAAQ,IAAI,QAAQ;AACtB,cAAQ,QAAQ,aAAa,OAAO,SAAS,UAAU;AACrD,cAAM,cAAe,QAAQ,aAAa,UAA6B,CAAC;AACxE,cAAM,YAAY,YAAY;AAG9B,YAAI,cAAc,OAAO;AACvB;AAAA,QACF;AAGA,cAAM,eACJ,cAAc,QACb,OAAO,cAAc,YAAY,UAAU,aAAa,SACxD,cAAc,UAAa,SAAS,KAAK,WAAW;AAEvD,YAAI,cAAc;AAChB,cAAI;AACF,kBAAM,QAAQ,UAAU;AAGxB,gBAAI,OAAO,cAAc,YAAY,UAAU,WAAW;AACxD,oBAAM,aAAa,MAAM,UAAU,UAAU,SAAS,OAAO,QAAQ,IAAI;AACzE,kBAAI,CAAC,YAAY;AACf,sBAAM,OAAO,GAAG,EAAE,KAAK;AAAA,kBACrB,OAAO;AAAA,kBACP,SAAS;AAAA,gBACX,CAAC;AACD;AAAA,cACF;AAAA,YACF;AAAA,UACF,SAAS,KAAK;AACZ,kBAAM,OAAO,GAAG,EAAE,KAAK;AAAA,cACrB,OAAO;AAAA,cACP,SAAS;AAAA,YACX,CAAC;AAAA,UACH;AAAA,QACF;AAAA,MACF,CAAC;AAAA,IACH;AAAA,EACF;AAGA,MAAI,SAAS,WAAW,QAAQ;AAC9B,UAAM,QAAQ,SAAS,kBAAkB;AAAA,MACvC,QAAQ;AAAA,MACR,GAAG,QAAQ,UAAU;AAAA,IACvB,CAAC;AAAA,EACH;AAEA,SAAO;AACT;AAEA,eAAsB,WAAW,SAAwB,MAAc,MAAc;AACnF,MAAI;AACF,UAAM,QAAQ,OAAO,EAAE,MAAM,KAAK,CAAC;AAAA,EACrC,SAAS,KAAK;AACZ,YAAQ,IAAI,MAAM,GAAG;AACrB,YAAQ,KAAK,CAAC;AAAA,EAChB;AACF;;;AChLO,SAAS,oBAAoB,IAA2B;AAC7D,SAAO;AACT;;;ACFO,IAAM,eAAe,oBAAoB,CAAC,QAAQ;AACvD,MAAI,IAAI,cAAc;AAAA,IACpB,QAAQ;AAAA,MACN,MAAM,CAAC,QAAQ;AAAA,IACjB;AAAA,IACA,SAAS,YAAY;AACnB,aAAO;AAAA,QACL,QAAQ;AAAA,QACR,SAAS;AAAA,MACX;AAAA,IACF;AAAA,EACF,CAAC;AACH,CAAC;","names":[]}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@a_jackie_z/fastify",
+  "version": "1.0.0",
+  "description": "A collection of Fastify plugins and utilities for building robust web applications.",
+  "license": "MIT",
+  "author": "Sang Lu <connect.with.sang@gmail.com>",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup"
+  },
+  "dependencies": {
+    "@fastify/jwt": "^10.0.0",
+    "@fastify/rate-limit": "^10.3.0",
+    "@fastify/swagger": "^9.6.1",
+    "@fastify/swagger-ui": "^5.2.4",
+    "@fastify/type-provider-typebox": "^6.1.0",
+    "@sinclair/typebox": "^0.34.47",
+    "fastify": "^5.7.1",
+    "typebox": "^1.0.79"
+  },
+  "devDependencies": {
+    "@types/node": "^25.0.9",
+    "tsup": "^8.5.1",
+    "tsx": "^4.7.0",
+    "typescript": "^5.9.3"
+  }
+}