@fedify/nestjs/dist/index.js

Integrate Fedify with Nest.js

//#region rolldown:runtime
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __commonJS = (cb, mod) => function() {
	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __copyProps = (to, from, except, desc) => {
	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
		key = keys[i];
		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
			get: ((k) => from[k]).bind(null, key),
			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
		});
	}
	return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
	value: mod,
	enumerable: true
}) : target, mod));

//#endregion
const __nestjs_common = __toESM(require("@nestjs/common"));
const __fedify_fedify = __toESM(require("@fedify/fedify"));
const node_buffer = __toESM(require("node:buffer"));
const node_stream = __toESM(require("node:stream"));

//#region src/fedify.constants.ts
const FEDIFY_FEDERATION = "FEDIFY_FEDERATION";

//#endregion
//#region ../../node_modules/.pnpm/@oxc-project+runtime@0.75.0/node_modules/@oxc-project/runtime/src/helpers/decorate.js
var require_decorate = __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.75.0/node_modules/@oxc-project/runtime/src/helpers/decorate.js"(exports, module) {
	function __decorate(decorators, target, key, desc) {
		var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
		if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
		else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
		return c > 3 && r && Object.defineProperty(target, key, r), r;
	}
	module.exports = __decorate, module.exports.__esModule = true, module.exports["default"] = module.exports;
} });

//#endregion
//#region src/fedify.module.ts
var import_decorate$1 = __toESM(require_decorate());
var _FedifyModule;
let FedifyModule = _FedifyModule = class FedifyModule$1 {
	static forRoot(options) {
		const providers = [{
			provide: FEDIFY_FEDERATION,
			useFactory: () => {
				const federationOptions = { ...options };
				federationOptions.kv = options.kv || new __fedify_fedify.MemoryKvStore();
				const federation = (0, __fedify_fedify.createFederation)(federationOptions);
				return federation;
			}
		}];
		return {
			module: _FedifyModule,
			providers,
			exports: [FEDIFY_FEDERATION],
			global: true
		};
	}
};
FedifyModule = _FedifyModule = (0, import_decorate$1.default)([(0, __nestjs_common.Module)({})], FedifyModule);

//#endregion
//#region src/fedify.middleware.ts
var import_decorate = __toESM(require_decorate());
function integrateFederation(federation, contextDataFactory) {
	let FedifyIntegrationMiddleware = class FedifyIntegrationMiddleware$1 {
		async use(req, res, next) {
			let notFound = false;
			let notAcceptable = false;
			const contextData = await contextDataFactory(req, res);
			const webRequest = fromERequest(req);
			const response = await federation.fetch(webRequest, {
				contextData,
				onNotFound: () => {
					notFound = true;
					next();
					return new Response("Not found", { status: 404 });
				},
				onNotAcceptable: () => {
					notAcceptable = true;
					next();
					return new Response("Not acceptable", {
						status: 406,
						headers: {
							"Content-Type": "text/plain",
							Vary: "Accept"
						}
					});
				}
			});
			if (notFound || notAcceptable && req.route != null) return;
			await setEResponse(res, response);
			next();
		}
	};
	FedifyIntegrationMiddleware = (0, import_decorate.default)([(0, __nestjs_common.Injectable)()], FedifyIntegrationMiddleware);
	return FedifyIntegrationMiddleware;
}
function fromERequest(req) {
	const url = `${req.protocol}://${req.header("Host") ?? req.hostname}${req.url}`;
	const headers = new Headers();
	for (const [key, value] of Object.entries(req.headers)) if (Array.isArray(value)) for (const v of value) headers.append(key, v);
	else if (typeof value === "string") headers.append(key, value);
	return new Request(url, {
		method: req.method,
		headers,
		duplex: "half",
		body: req.method === "GET" || req.method === "HEAD" ? void 0 : node_stream.Readable.toWeb(req)
	});
}
function setEResponse(res, response) {
	res.status(response.status);
	response.headers.forEach((value, key) => res.setHeader(key, value));
	if (response.body == null) return Promise.resolve();
	const body = response.body;
	return new Promise((resolve) => {
		const reader = body.getReader();
		reader.read().then(function read({ done, value }) {
			if (done) {
				reader.releaseLock();
				resolve();
				return;
			}
			res.write(node_buffer.Buffer.from(value));
			reader.read().then(read);
		});
	});
}

//#endregion
exports.FEDIFY_FEDERATION = FEDIFY_FEDERATION;
Object.defineProperty(exports, 'FedifyModule', {
  enumerable: true,
  get: function () {
    return FedifyModule;
  }
});
exports.integrateFederation = integrateFederation;