oc-fastify-server-adapter 0.1.3 → 0.1.4

package/dist/index.d.ts

@@ -100,6 +100,20 @@ export interface FastifyServerAdapterOptions {
     host?: string;
     port?: number | string;
     trustProxy?: boolean | string | string[] | number;
+    /**
+     * When enabled, Fastify treats `/foo` and `/foo/` as the same route, matching
+     * Express' default (non-strict) trailing-slash behavior. This is convenient
+     * for incoming requests that include a trailing slash, but it is slightly less
+     * performant than Fastify's native routing and requires OC to deduplicate
+     * routes that only differ by a trailing slash.
+     *
+     * Defaults to `false` to keep Fastify's faster native routing. OC's own routes
+     * never rely on trailing slashes, so the default is safe for the built-in
+     * registry endpoints.
+     *
+     * @default false
+     */
+    ignoreTrailingSlash?: boolean;
 }
 export type HttpServerAdapterFactory<TOptions = unknown, TNative = unknown> = {
     (options?: unknown): HttpServerAdapter<TNative>;

package/dist/index.js

@@ -28,15 +28,19 @@ class FastifyHttpServerAdapter {
     bodyInflationRegistered = false;
     bodyLimit = defaultBodyLimit;
     host;
+    ignoreTrailingSlash;
+    registeredRoutes = new Set();
     routes = [];
     optionsRoutesRegistered = false;
     constructor(options = {}) {
         this.host = options.host;
+        this.ignoreTrailingSlash = options.ignoreTrailingSlash ?? false;
         this.app = (0, fastify_1.default)({
             bodyLimit: this.bodyLimit,
             exposeHeadRoutes: true,
             logger: false,
             routerOptions: {
+                ignoreTrailingSlash: this.ignoreTrailingSlash,
                 querystringParser: (str) => (0, node_querystring_1.parse)(str)
             },
             trustProxy: options.trustProxy
@@ -156,6 +160,18 @@ class FastifyHttpServerAdapter {
     }
     route(method, routePath, id, handlers) {
         const url = toFastifyRoutePath(routePath);
+        // With `ignoreTrailingSlash` enabled Fastify treats `/foo` and `/foo/` as
+        // the same route and throws on duplicate registrations. Deduplicate so a
+        // consumer registering both variants does not crash the server. When the
+        // option is disabled the two paths are distinct routes, so we let Fastify
+        // register both.
+        if (this.ignoreTrailingSlash) {
+            const routeKey = `${method}:${stripTrailingSlash(url)}`;
+            if (this.registeredRoutes.has(routeKey)) {
+                return;
+            }
+            this.registeredRoutes.add(routeKey);
+        }
         this.routes.push({ method, path: url });
         this.app.route({
             bodyLimit: this.bodyLimit,
@@ -506,10 +522,13 @@ function isFastifyAdapterOptions(options) {
     const port = candidate.port;
     const host = candidate.host;
     const trustProxy = candidate.trustProxy;
+    const ignoreTrailingSlash = candidate.ignoreTrailingSlash;
     return ((typeof port === 'undefined' ||
         typeof port === 'number' ||
         typeof port === 'string') &&
         (typeof host === 'undefined' || typeof host === 'string') &&
+        (typeof ignoreTrailingSlash === 'undefined' ||
+            typeof ignoreTrailingSlash === 'boolean') &&
         (typeof trustProxy === 'undefined' ||
             typeof trustProxy === 'boolean' ||
             typeof trustProxy === 'string' ||
@@ -520,6 +539,9 @@ function isFastifyAdapterOptions(options) {
 function toFastifyRoutePath(routePath) {
     return routePath.replace(/\*[A-Za-z0-9_]+/g, '*');
 }
+function stripTrailingSlash(value) {
+    return value !== '/' && value.endsWith('/') ? value.slice(0, -1) : value;
+}
 function routePathMatches(routePath, pathname) {
     if (routePath === pathname) {
         return true;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "oc-fastify-server-adapter",
-	"version": "0.1.3",
+	"version": "0.1.4",
 	"description": "Fastify HTTP server adapter for OC",
 	"main": "./dist/index.js",
 	"types": "./dist/index.d.ts",