@fedify/nuxt 2.2.0-dev.0

package/dist/mod.js

@@ -0,0 +1,68 @@
+import { addServerHandler, addServerPlugin, addServerTemplate, createResolver, defineNuxtModule, resolveAlias } from "@nuxt/kit";
+import { isAbsolute, resolve } from "node:path";
+//#region src/module.ts
+function resolveModulePath(modulePath, aliases, rootDir) {
+	const resolved = resolveAlias(modulePath, aliases);
+	if (isAbsolute(resolved)) return resolved;
+	if (resolved.startsWith("./") || resolved.startsWith("../")) return resolve(rootDir, resolved);
+	return resolved;
+}
+function buildContextFactoryResolver(contextDataFactoryModule) {
+	if (contextDataFactoryModule == null) return "const contextDataFactory = undefined;";
+	return `
+const contextDataFactory =
+  contextFactoryModule.default ??
+  contextFactoryModule.contextDataFactory;
+if (contextDataFactory == null) {
+  throw new TypeError(
+    \'@fedify/nuxt: contextDataFactoryModule must export a function as "default" or named "contextDataFactory", but neither was found.\'
+  );
+}
+if (typeof contextDataFactory !== 'function') {
+  throw new TypeError(
+    \'@fedify/nuxt: contextDataFactoryModule must export a function as "default" or named "contextDataFactory".\'
+  );
+}`;
+}
+/**
+* Nuxt module to integrate Fedify with Nuxt/Nitro request handling.
+*/
+const fedifyNuxtModule = defineNuxtModule({
+	meta: {
+		name: "@fedify/nuxt",
+		configKey: "fedify"
+	},
+	defaults: {
+		federationModule: "#server/federation",
+		contextDataFactoryModule: void 0
+	},
+	setup(options, nuxt) {
+		const resolver = createResolver(import.meta.url);
+		const rootDir = nuxt.options.rootDir;
+		const federationModule = resolveModulePath(options.federationModule, nuxt.options.alias, rootDir);
+		const contextDataFactoryModule = options.contextDataFactoryModule == null ? void 0 : resolveModulePath(options.contextDataFactoryModule, nuxt.options.alias, rootDir);
+		const middlewareFilename = "fedify-nuxt-options.mjs";
+		addServerTemplate({
+			filename: middlewareFilename,
+			getContents: () => {
+				const imports = [`import * as federationModule from ${JSON.stringify(federationModule)};`, `import { createFedifyMiddleware } from ${JSON.stringify(resolver.resolve("../src/runtime/server/middleware.ts"))};`];
+				if (contextDataFactoryModule != null) imports.push(`import * as contextFactoryModule from ${JSON.stringify(contextDataFactoryModule)};`);
+				return [
+					...imports,
+					"const federation = federationModule.default ?? federationModule.federation;",
+					buildContextFactoryResolver(contextDataFactoryModule ?? null),
+					"export default createFedifyMiddleware(federation, contextDataFactory);",
+					""
+				].join("\n");
+			}
+		});
+		addServerHandler({
+			route: "",
+			middleware: true,
+			handler: middlewareFilename
+		});
+		addServerPlugin(resolver.resolve("../src/runtime/server/plugin.ts"));
+	}
+});
+//#endregion
+export { fedifyNuxtModule as default };

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "@fedify/nuxt",
+  "version": "2.2.0-dev.0",
+  "description": "Integrate Fedify with Nuxt",
+  "keywords": [
+    "Fedify",
+    "ActivityPub",
+    "Fediverse",
+    "Nuxt"
+  ],
+  "author": {
+    "name": "ChanHaeng Lee",
+    "email": "2chanhaeng@gmail.com",
+    "url": "https://chomu.dev/"
+  },
+  "homepage": "https://fedify.dev/",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fedify-dev/fedify.git",
+    "directory": "packages/nuxt"
+  },
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/fedify-dev/fedify/issues"
+  },
+  "funding": [
+    "https://opencollective.com/fedify",
+    "https://github.com/sponsors/dahlia"
+  ],
+  "type": "module",
+  "main": "./dist/mod.cjs",
+  "module": "./dist/mod.js",
+  "types": "./dist/mod.d.ts",
+  "exports": {
+    ".": {
+      "require": {
+        "types": "./dist/mod.d.cts",
+        "default": "./dist/mod.cjs"
+      },
+      "import": {
+        "types": "./dist/mod.d.ts",
+        "default": "./dist/mod.js"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist/",
+    "src/runtime/",
+    "package.json"
+  ],
+  "peerDependencies": {
+    "@nuxt/kit": "^4.4.0",
+    "h3": "^1.15.0",
+    "nuxt": "^4.4.2",
+    "@fedify/fedify": "^2.2.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.17.0",
+    "@nuxt/schema": "^4.4.0",
+    "tsdown": "^0.21.6",
+    "typescript": "^5.9.2",
+    "@fedify/fixture": "^2.0.0"
+  },
+  "scripts": {
+    "build:self": "tsdown",
+    "build": "pnpm --filter @fedify/nuxt... run build:self",
+    "prepublish": "pnpm build",
+    "test": "node --experimental-transform-types --test"
+  }
+}

package/src/runtime/server/lib.ts

@@ -0,0 +1,4 @@
+export const NOT_ACCEPTABLE_BODY = "Not acceptable";
+
+export const DEFERRED_NOT_ACCEPTABLE_CONTEXT_KEY =
+  "__fedify_deferred_not_acceptable__";

package/src/runtime/server/logic.test.ts

@@ -0,0 +1,50 @@
+import { test } from "@fedify/fixture";
+import { equal, ok, strictEqual } from "node:assert/strict";
+import { fetchWithFedify, resolveDeferredNotAcceptable } from "./logic.ts";
+
+test(
+  "genuine handler 406 must be classified as handled",
+  async () => {
+    const handlerBody = JSON.stringify({ error: "custom reason" });
+    const handlerResponse = new Response(handlerBody, {
+      status: 406,
+      headers: { "Content-Type": "application/json" },
+    });
+
+    const result = await fetchWithFedify(
+      () => Promise.resolve(handlerResponse),
+      new Request("https://example.com/inbox"),
+      undefined,
+    );
+
+    equal(result.kind, "handled");
+    if (result.kind === "handled") {
+      strictEqual(result.response, handlerResponse);
+    }
+  },
+);
+
+test(
+  "framework intentional 404 on shared route must not become 406",
+  () => {
+    // When a route handler ran (routeHandled=true), preserve the
+    // framework's 404 instead of rewriting it to 406.
+    const result = resolveDeferredNotAcceptable(true, 404, true);
+    equal(
+      result,
+      undefined,
+      "should preserve framework 404 when route was handled",
+    );
+  },
+);
+
+test(
+  "deferred 406 fires when no route handler matched",
+  () => {
+    // When no route handler matched (routeHandled=false), the 404
+    // is a genuine route miss and should be converted to 406.
+    const result = resolveDeferredNotAcceptable(true, 404, false);
+    ok(result, "should return 406 when no route handled the request");
+    equal(result!.status, 406);
+  },
+);

package/src/runtime/server/logic.ts

@@ -0,0 +1,60 @@
+import type { FederationFetchOptions } from "@fedify/fedify/federation";
+import { NOT_ACCEPTABLE_BODY } from "./lib.ts";
+
+export { DEFERRED_NOT_ACCEPTABLE_CONTEXT_KEY } from "./lib.ts";
+
+const DUMMY_NOT_FOUND_RESPONSE = new Response("", { status: 404 });
+
+const createNotAcceptableResponse = () =>
+  new Response(NOT_ACCEPTABLE_BODY, {
+    status: 406,
+    headers: {
+      "Content-Type": "text/plain",
+      Vary: "Accept",
+    },
+  });
+
+export type FetchResult =
+  | { kind: "handled"; response: Response }
+  | { kind: "not-found" }
+  | { kind: "not-acceptable" };
+
+export async function fetchWithFedify<TContextData = unknown>(
+  fetcher: (
+    request: Request,
+    options: FederationFetchOptions<TContextData>,
+  ) => Promise<Response>,
+  request: Request,
+  contextData: TContextData,
+): Promise<FetchResult> {
+  let notAcceptableResponse: Response | null = null;
+
+  const response = await fetcher(request, {
+    contextData,
+    onNotFound: () => DUMMY_NOT_FOUND_RESPONSE,
+    onNotAcceptable: () => {
+      notAcceptableResponse = createNotAcceptableResponse();
+      return notAcceptableResponse;
+    },
+  });
+
+  if (response === DUMMY_NOT_FOUND_RESPONSE) {
+    return { kind: "not-found" };
+  }
+
+  if (notAcceptableResponse != null && response === notAcceptableResponse) {
+    return { kind: "not-acceptable" };
+  }
+
+  return { kind: "handled", response };
+}
+
+export function resolveDeferredNotAcceptable(
+  isDeferred: boolean,
+  frameworkStatus: number,
+  routeHandled?: boolean,
+): Response | undefined {
+  if (!isDeferred || frameworkStatus !== 404) return undefined;
+  if (routeHandled) return undefined;
+  return createNotAcceptableResponse();
+}

package/src/runtime/server/middleware.ts

@@ -0,0 +1,44 @@
+import type { Federation } from "@fedify/fedify/federation";
+import { defineEventHandler, type H3Event, toWebRequest } from "h3";
+import { DEFERRED_NOT_ACCEPTABLE_CONTEXT_KEY } from "./lib.ts";
+import { fetchWithFedify } from "./logic.ts";
+
+function assertFederation(
+  federation: unknown,
+): asserts federation is Federation<unknown> {
+  const candidate = federation as { fetch?: unknown } | null | undefined;
+  if (candidate == null || typeof candidate.fetch !== "function") {
+    throw new TypeError(
+      "@fedify/nuxt: Federation instance is missing. " +
+        "Export default Federation (or named 'federation') from the configured module.",
+    );
+  }
+}
+
+export function createFedifyMiddleware(
+  federation: unknown,
+  contextDataFactory?: (event: H3Event, request: Request) => unknown,
+) {
+  assertFederation(federation);
+
+  return defineEventHandler(async (event) => {
+    const request = toWebRequest(event);
+    const contextData = typeof contextDataFactory === "function"
+      ? await contextDataFactory(event, request)
+      : undefined;
+
+    const result = await fetchWithFedify(
+      federation.fetch.bind(federation),
+      request,
+      contextData,
+    );
+
+    if (result.kind === "not-found") return;
+    if (result.kind === "not-acceptable") {
+      event.context[DEFERRED_NOT_ACCEPTABLE_CONTEXT_KEY] = true;
+      return;
+    }
+
+    return result.response;
+  });
+}

package/src/runtime/server/plugin.test.ts

@@ -0,0 +1,118 @@
+import { test } from "@fedify/fixture";
+import type { H3Event } from "h3";
+import { equal, ok } from "node:assert/strict";
+import {
+  DEFERRED_NOT_ACCEPTABLE_CONTEXT_KEY,
+  NOT_ACCEPTABLE_BODY,
+} from "./lib.ts";
+import fedifyPlugin from "./plugin.ts";
+
+interface MockResponse {
+  statusCode: number;
+  statusMessage?: string;
+  setHeader(name: string, value: string): void;
+  getHeader(name: string): string | undefined;
+}
+
+function createMockResponse(statusCode: number): MockResponse {
+  const headers = new Map<string, string>();
+  return {
+    statusCode,
+    setHeader(name: string, value: string) {
+      headers.set(name.toLowerCase(), value);
+    },
+    getHeader(name: string) {
+      return headers.get(name.toLowerCase());
+    },
+  };
+}
+
+function registerBeforeResponseHook() {
+  let callback:
+    | ((event: H3Event, payload: { body?: unknown }) => void)
+    | undefined;
+
+  fedifyPlugin({
+    hooks: {
+      hook(name, registeredCallback) {
+        equal(name, "beforeResponse");
+        callback = registeredCallback;
+      },
+    },
+  });
+
+  ok(callback, "beforeResponse hook should be registered");
+  return callback;
+}
+
+test(
+  "plugin rewrites deferred 404 without matched route to 406",
+  () => {
+    const beforeResponse = registerBeforeResponseHook();
+    const response = createMockResponse(404);
+    const payload = { body: "original body" };
+    const event = {
+      context: {
+        [DEFERRED_NOT_ACCEPTABLE_CONTEXT_KEY]: true,
+      },
+      node: { res: response },
+    };
+
+    beforeResponse(event as unknown as H3Event, payload);
+
+    equal(response.statusCode, 406);
+    equal(response.getHeader("content-type"), "text/plain");
+    equal(response.getHeader("vary"), "Accept");
+    equal(payload.body, NOT_ACCEPTABLE_BODY);
+    equal(
+      event.context[DEFERRED_NOT_ACCEPTABLE_CONTEXT_KEY],
+      undefined,
+    );
+  },
+);
+
+test(
+  "plugin ignores 404 when deferred flag is absent",
+  () => {
+    const beforeResponse = registerBeforeResponseHook();
+    const response = createMockResponse(404);
+    const payload = { body: "regular 404" };
+    const event: H3Event = {
+      context: {},
+      node: { res: response },
+    } as unknown as H3Event;
+
+    beforeResponse(event, payload);
+
+    equal(response.statusCode, 404);
+    equal(response.getHeader("content-type"), undefined);
+    equal(payload.body, "regular 404");
+  },
+);
+
+test(
+  "plugin preserves shared-route 404 when Nuxt matched the route",
+  () => {
+    const beforeResponse = registerBeforeResponseHook();
+    const response = createMockResponse(404);
+    const payload = { body: "missing actor page" };
+    const event = {
+      context: {
+        [DEFERRED_NOT_ACCEPTABLE_CONTEXT_KEY]: true,
+        matchedRoute: {},
+      },
+      node: { res: response },
+    };
+
+    beforeResponse(event as unknown as H3Event, payload);
+
+    equal(response.statusCode, 404);
+    equal(response.getHeader("content-type"), undefined);
+    equal(response.getHeader("vary"), undefined);
+    equal(payload.body, "missing actor page");
+    equal(
+      event.context[DEFERRED_NOT_ACCEPTABLE_CONTEXT_KEY],
+      undefined,
+    );
+  },
+);

package/src/runtime/server/plugin.ts

@@ -0,0 +1,49 @@
+import type { H3Event } from "h3";
+import { getResponseStatus, setResponseHeader, setResponseStatus } from "h3";
+import {
+  DEFERRED_NOT_ACCEPTABLE_CONTEXT_KEY,
+  NOT_ACCEPTABLE_BODY,
+} from "./lib.ts";
+import { resolveDeferredNotAcceptable } from "./logic.ts";
+
+interface ResponsePayload {
+  body?: unknown;
+}
+
+interface MinimalNitroApp {
+  hooks: {
+    hook(
+      name: "beforeResponse",
+      callback: (event: H3Event, payload: ResponsePayload) => void,
+    ): void;
+  };
+}
+
+type NitroAppPlugin = (nitroApp: MinimalNitroApp) => void;
+
+const fedifyPlugin: NitroAppPlugin = (nitroApp: MinimalNitroApp) => {
+  nitroApp.hooks.hook(
+    "beforeResponse",
+    (event: H3Event, payload: ResponsePayload) => {
+      const deferred =
+        event.context[DEFERRED_NOT_ACCEPTABLE_CONTEXT_KEY] === true;
+      delete event.context[DEFERRED_NOT_ACCEPTABLE_CONTEXT_KEY];
+
+      const negotiatedResponse = resolveDeferredNotAcceptable(
+        deferred,
+        getResponseStatus(event),
+        event.context.matchedRoute != null,
+      );
+      if (negotiatedResponse == null) return;
+
+      setResponseStatus(event, negotiatedResponse.status);
+      negotiatedResponse.headers.forEach((value: string, key: string) => {
+        setResponseHeader(event, key, value);
+      });
+
+      payload.body = NOT_ACCEPTABLE_BODY;
+    },
+  );
+};
+
+export default fedifyPlugin;