@fedify/init 2.0.0-dev.0

package/dist/templates/elysia/index/bun.ts.tpl

@@ -0,0 +1,13 @@
+import { fedify } from "@fedify/elysia";
+import { Elysia } from "elysia";
+import federation from "./federation.ts";
+import "./logging.ts";
+
+const app = new Elysia();
+
+app
+  .use(fedify(federation, () => undefined))
+  .get("/", () => "Hello, Fedify!")
+  .listen(3000, () => {
+    console.log("Server started at http://localhost:3000");
+  })

package/dist/templates/elysia/index/deno.ts.tpl

@@ -0,0 +1,19 @@
+import { fedify } from "@fedify/elysia";
+import { Elysia } from "elysia";
+import federation from "./federation.ts";
+import "./logging.ts";
+
+const app = new Elysia();
+
+app
+  .use(fedify(federation, () => undefined))
+  .get("/", () => "Hello, Fedify!")
+
+Deno.serve(
+  {
+    port: 3000,
+    onListen: ({ port, hostname }) =>
+      console.log("Server started at http://" + hostname + ":" + port),
+  },
+  app.fetch,
+) 

package/dist/templates/elysia/index/node.ts.tpl

@@ -0,0 +1,14 @@
+import { fedify } from "@fedify/elysia";
+import { Elysia } from "elysia";
+import federation from "./federation.ts";
+import "./logging.ts";
+import { node } from '@elysiajs/node'
+
+const app = new Elysia({ adapter: node() });
+
+app
+  .use(fedify(federation, () => undefined))
+  .get("/", () => "Hello, Fedify!")
+  .listen(3000, () => {
+    console.log("Server started at http://localhost:3000");
+  })

package/dist/templates/express/app.ts.tpl

@@ -0,0 +1,16 @@
+import { integrateFederation } from "@fedify/express";
+import { getLogger } from "@logtape/logtape";
+import express from "express";
+import federation from "./federation.ts";
+
+const logger = getLogger("/* logger */");
+
+export const app = express();
+
+app.set("trust proxy", true);
+
+app.use(integrateFederation(federation, () => undefined));
+
+app.get("/", (_, res) => res.send("Hello, Fedify!"));
+
+export default app;

package/dist/templates/express/index.ts.tpl

@@ -0,0 +1,6 @@
+import app from "./app.ts";
+import "./logging.ts";
+
+app.listen(8000, () => {
+  console.log("Server started at http://localhost:8000");
+});

package/dist/templates/hono/app.tsx.tpl

@@ -0,0 +1,14 @@
+// @ts-nocheck this file is just a template
+import { Hono } from "/* hono */";
+import { federation } from "@fedify/hono";
+import { getLogger } from "@logtape/logtape";
+import fedi from "./federation.ts";
+
+const logger = getLogger("/* logger */");
+
+const app = new Hono();
+app.use(federation(fedi, () => undefined));
+
+app.get("/", (c) => c.text("Hello, Fedify!"));
+
+export default app;

package/dist/templates/hono/index/bun.ts.tpl

@@ -0,0 +1,10 @@
+import { behindProxy } from "x-forwarded-fetch";
+import app from "./app.tsx";
+import "./logging.ts";
+
+const server = Bun.serve({
+  port: 8000,
+  fetch: behindProxy(app.fetch.bind(app)),
+});
+
+console.log("Server started at", server.url.href);

package/dist/templates/hono/index/deno.ts.tpl

@@ -0,0 +1,13 @@
+import { behindProxy } from "@hongminhee/x-forwarded-fetch";
+import "@std/dotenv/load";
+import app from "./app.tsx";
+import "./logging.ts";
+
+Deno.serve(
+  {
+    port: 8000,
+    onListen: ({ port, hostname }) =>
+      console.log("Server started at http://" + hostname + ":" + port),
+  },
+  behindProxy(app.fetch.bind(app)),
+);

package/dist/templates/hono/index/node.ts.tpl

@@ -0,0 +1,14 @@
+// @ts-nocheck this file is just a template
+import { serve } from "@hono/node-server";
+import { behindProxy } from "x-forwarded-fetch";
+import app from "./app.tsx";
+import "./logging.ts";
+
+serve(
+  {
+    port: 8000,
+    fetch: behindProxy(app.fetch.bind(app)),
+  },
+  (info) =>
+    console.log("Server started at http://" + info.address + ":" + info.port),
+);

package/dist/templates/next/middleware.ts.tpl

@@ -0,0 +1,45 @@
+import { fedifyWith } from "@fedify/next";
+import federation from "./federation";
+
+export default fedifyWith(federation)(
+/*
+  function (request: Request) {
+    // If you need to handle other requests besides federation
+    // requests in middleware, you can do it here.
+    // If you handle only federation requests in middleware,
+    // you don't need this function.
+    return NextResponse.next();
+  },
+*/
+)
+
+// This config needs because middleware process only requests with the
+// "Accept" header matching the federation accept regex.
+// More details: https://nextjs.org/docs/app/api-reference/file-conventions/middleware#config-object-optional
+export const config = {
+  runtime: "nodejs",
+  matcher: [
+    {
+      source: "/:path*",
+      has: [
+        {
+          type: "header",
+          key: "Accept",
+          value: ".*application\\/((jrd|activity|ld)\\+json|xrd\\+xml).*",
+        },
+      ],
+    },
+    {
+      source: "/:path*",
+      has: [
+        {
+          type: "header",
+          key: "content-type",
+          value: ".*application\\/((jrd|activity|ld)\\+json|xrd\\+xml).*",
+        },
+      ],
+    },
+    { source: "/.well-known/nodeinfo" },
+    { source: "/.well-known/x-nodeinfo2" },
+  ],
+};

package/dist/templates/nitro/.env.test.tpl

@@ -0,0 +1 @@
+HOST=127.0.0.1

package/dist/templates/nitro/nitro.config.ts.tpl

@@ -0,0 +1,14 @@
+import { defineNitroConfig } from "nitropack/config"
+
+// https://nitro.build/config
+export default defineNitroConfig({
+  errorHandler: "~/error",
+  esbuild: {
+    options: {
+      target: "esnext",
+    },
+  },
+  compatibilityDate: "latest",
+  srcDir: "server",
+  imports: false
+});

package/dist/templates/nitro/server/error.ts.tpl

@@ -0,0 +1,3 @@
+import { onError } from "@fedify/h3";
+
+export default onError;

package/dist/templates/nitro/server/middleware/federation.ts.tpl

@@ -0,0 +1,8 @@
+
+import { integrateFederation } from "@fedify/h3";
+import federation from "../federation"
+
+export default integrateFederation(
+  federation,
+  (event, request) => undefined,
+);

package/dist/test/action.mjs

@@ -0,0 +1,15 @@
+import { set } from "../utils.mjs";
+import { checkRequiredDbs } from "./db.mjs";
+import { fillEmptyOptions } from "./fill.mjs";
+import run_default from "./run.mjs";
+import { emptyTestDir, genRunId, genTestDirPrefix, logTestDir } from "./utils.mjs";
+import { pipe, tap, when } from "@fxts/core";
+
+//#region src/test/action.ts
+const runTestInit = (options) => pipe(options, set("runId", genRunId), set("testDirPrefix", genTestDirPrefix), tap(emptyTestDir), fillEmptyOptions, tap(checkRequiredDbs), tap(logTestDir), tap(when(isDryRun, run_default(true))), tap(when(isHydRun, run_default(false))));
+const isDryRun = ({ dryRun }) => dryRun;
+const isHydRun = ({ hydRun }) => hydRun;
+var action_default = runTestInit;
+
+//#endregion
+export { action_default as default };

package/dist/test/create.mjs

@@ -0,0 +1,92 @@
+import { CommandError, printErrorMessage, printMessage, product, runSubCommand } from "../utils.mjs";
+import pm_default from "../json/pm.mjs";
+import { kvStores, messageQueues } from "../lib.mjs";
+import webframeworks_default from "../webframeworks.mjs";
+import { filter, isEmpty, pipe, toArray } from "@fxts/core";
+import process from "node:process";
+import { values } from "@optique/core";
+import { appendFile, mkdir } from "node:fs/promises";
+import { join as join$1, sep } from "node:path";
+
+//#region src/test/create.ts
+const BANNED_PMS = ["bun", "yarn"];
+const createTestApp = (testDirPrefix, dry) => async (options) => {
+	const testDir = join$1(testDirPrefix, ...options);
+	const vals = values(testDir.split(sep).slice(-4));
+	try {
+		await saveOutputs(testDir, await runSubCommand(toArray(genInitCommand(testDir, dry, options)), {
+			cwd: join$1(import.meta.dirname, "../.."),
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		}));
+		printMessage`  Pass: ${vals}`;
+		return testDir;
+	} catch (error) {
+		if (error instanceof CommandError) await saveOutputs(testDir, {
+			stdout: error.stdout,
+			stderr: error.stderr
+		});
+		else await saveOutputs(testDir, {
+			stdout: "",
+			stderr: error instanceof Error ? error.message : String(error)
+		});
+		printMessage`  Fail: ${vals}`;
+		return "";
+	}
+};
+var create_default = createTestApp;
+function* genInitCommand(testDir, dry, [webFramework, packageManager, kvStore, messageQueue]) {
+	yield "deno";
+	yield "run";
+	yield "-A";
+	yield "src/test/execute.ts";
+	yield "init";
+	yield testDir;
+	yield "-w";
+	yield webFramework;
+	yield "-p";
+	yield packageManager;
+	yield "-k";
+	yield kvStore;
+	yield "-m";
+	yield messageQueue;
+	if (dry) yield "-d";
+}
+const generateTestCases = ({ webFramework, packageManager, kvStore, messageQueue }) => {
+	const pms = filterPackageManager(packageManager);
+	exitIfCasesEmpty([
+		webFramework,
+		pms,
+		kvStore,
+		messageQueue
+	]);
+	return product(webFramework, pms, kvStore, messageQueue);
+};
+const filterPackageManager = (pm) => pipe(pm, filter((pm$1) => BANNED_PMS.includes(pm$1) ? printErrorMessage`${pm_default[pm$1]["label"]} is not \
+supported in test mode yet because ${pm_default[pm$1]["label"]} don't \
+support local file dependencies properly.` : true), toArray);
+const exitIfCasesEmpty = (cases) => {
+	if (cases.some(isEmpty)) {
+		printErrorMessage`No test cases to run. Exiting.`;
+		process.exit(1);
+	}
+};
+const saveOutputs = async (dirPath, { stdout, stderr }) => {
+	await mkdir(dirPath, { recursive: true });
+	if (stdout) await appendFile(join$1(dirPath, "out.txt"), stdout + "\n", "utf8");
+	if (stderr) await appendFile(join$1(dirPath, "err.txt"), stderr + "\n", "utf8");
+};
+function filterOptions(options) {
+	const [wf, pm, kv, mq] = options;
+	return [
+		webframeworks_default[wf].packageManagers,
+		kvStores[kv].packageManagers,
+		messageQueues[mq].packageManagers
+	].every((pms) => pms.includes(pm));
+}
+
+//#endregion
+export { create_default as default, filterOptions, generateTestCases };

package/dist/test/db.mjs

@@ -0,0 +1,42 @@
+import { printErrorMessage, printMessage } from "../utils.mjs";
+import { DB_TO_CHECK } from "../const.mjs";
+import db_to_check_default from "../json/db-to-check.mjs";
+import { concat, filter, pipe, toArray, uniq } from "@fxts/core";
+
+//#region src/test/db.ts
+/**
+* This function checks if a given port is open by attempting to fetch from
+* localhost at that port. So, may give false positives if the service does not
+* respond to HTTP requests.
+* @param port The port number to check.
+* @returns A promise that resolves to true if the port is open, else false.
+*/
+async function isPortOpen(port) {
+	try {
+		await fetch(`http://localhost:${port}`, { signal: AbortSignal.timeout(3e3) });
+		return true;
+	} catch (error) {
+		if (error instanceof TypeError) {
+			const msg = error.message.toLowerCase();
+			if (msg.includes("refused") || msg.includes("econnrefused")) return false;
+			return true;
+		}
+		if (error instanceof DOMException && error.name === "TimeoutError") return false;
+		return false;
+	}
+}
+const getRequiredDbs = ({ kvStore, messageQueue }) => pipe(kvStore, concat(messageQueue), uniq, filter((db) => DB_TO_CHECK.includes(db)), toArray);
+async function checkRequiredDbs(options) {
+	const dbs = Array.from(getRequiredDbs(options));
+	if (dbs.length === 0) return;
+	printMessage`Checking required databases...`;
+	for (const db of dbs) {
+		const info = db_to_check_default[db];
+		const port = String(info.defaultPort);
+		if (await isPortOpen(info.defaultPort)) printMessage`  ${info.name} is running on port ${port}.`;
+		else printErrorMessage`${info.name} is not running on port ${port}. Tests requiring ${info.name} may fail. Install: ${info.documentation}`;
+	}
+}
+
+//#endregion
+export { checkRequiredDbs };

package/dist/test/fill.mjs

@@ -0,0 +1,29 @@
+import { KV_STORE, MESSAGE_QUEUE, PACKAGE_MANAGER, WEB_FRAMEWORK } from "../const.mjs";
+import { isEmpty, omit, pipe } from "@fxts/core";
+
+//#region src/test/fill.ts
+const fillEmptyOptions = (options) => pipe(options, fillWebFramework, fillPackageManager, fillKVStore, fillMessageQueue, fillRunMode);
+const fillOption = (key, allValues) => (options) => ({
+	...options,
+	[key]: isEmpty(options[key]) ? allValues : options[key].filter((i) => allValues.includes(i))
+});
+const fillWebFramework = fillOption("webFramework", WEB_FRAMEWORK);
+const fillPackageManager = fillOption("packageManager", PACKAGE_MANAGER);
+const fillKVStore = fillOption("kvStore", KV_STORE);
+const fillMessageQueue = fillOption("messageQueue", MESSAGE_QUEUE);
+const fillRunMode = (options) => pipe(options, (options$1) => "noHydRun" in options$1 ? {
+	...omit(["noHydRun"], options$1),
+	hydRun: !options$1.noHydRun
+} : {
+	...options$1,
+	hydRun: true
+}, (options$1) => "noDryRun" in options$1 ? {
+	...omit(["noDryRun"], options$1),
+	dryRun: !options$1.noDryRun
+} : {
+	...options$1,
+	dryRun: true
+});
+
+//#endregion
+export { fillEmptyOptions };

package/dist/test/lookup.mjs

@@ -0,0 +1,183 @@
+import { printErrorMessage, printMessage, runSubCommand } from "../utils.mjs";
+import { getDevCommand } from "../lib.mjs";
+import webframeworks_default from "../webframeworks.mjs";
+import process from "node:process";
+import { values } from "@optique/core";
+import { spawn } from "node:child_process";
+import { createWriteStream } from "node:fs";
+import { join, sep } from "node:path";
+import { isEmpty } from "@fxts/core/index.js";
+
+//#region src/test/lookup.ts
+const HANDLE = "john";
+const STARTUP_TIMEOUT = 3e4;
+const CWD = process.cwd();
+const BANNED_WFS = ["next"];
+/**
+* Run servers for all generated apps and test them with the lookup command.
+*
+* @param dirs - Array of paths to generated app directories
+*/
+async function runServerAndLookupUser(dirs) {
+	const valid = dirs.filter(Boolean);
+	if (valid.length === 0) {
+		printErrorMessage`\nNo directories to lookup test.`;
+		return;
+	}
+	const filtered = filterWebFrameworks(valid);
+	printMessage`\nLookup Test start for ${String(filtered.length)} app(s)!`;
+	const results = await Array.fromAsync(filtered, testApp);
+	const successCount = results.filter(Boolean).length;
+	const failCount = results.length - successCount;
+	printMessage`Lookup Test Results:
+  Total: ${String(results.length)}
+  Passed: ${String(successCount)}
+  Failed: ${String(failCount)}\n\n`;
+}
+function filterWebFrameworks(dirs) {
+	const wfs = new Set(dirs.map((dir) => dir.split(sep).slice(-4, -3)[0]));
+	const hasBanned = BANNED_WFS.filter((wf) => wfs.has(wf));
+	if (isEmpty(hasBanned)) return dirs;
+	printErrorMessage`\n${values(hasBanned.map((wf) => webframeworks_default[wf]["label"]))} is not supported in lookup test yet.`;
+	return dirs.filter((dir) => !BANNED_WFS.includes(dir.split(sep).slice(-4, -3)[0]));
+}
+/**
+* Run the dev server and test with lookup command.
+*/
+async function testApp(dir) {
+	const [wf, pm, kv, mq] = dir.split(sep).slice(-4);
+	printMessage`  Testing ${values([
+		wf,
+		pm,
+		kv,
+		mq
+	])}...`;
+	const result = await serverClosure(dir, getDevCommand(pm), sendLookup);
+	printMessage`    Lookup ${result ? "successful" : "failed"} for ${values([
+		wf,
+		pm,
+		kv,
+		mq
+	])}!`;
+	if (!result) printMessage`    Check out these files for more details:
+      ${join(dir, "out.txt")} and 
+      ${join(dir, "err.txt")}\n`;
+	printMessage`\n`;
+	return result;
+}
+const sendLookup = async (port) => {
+	const serverUrl = `http://localhost:${port}`;
+	const lookupTarget = `${serverUrl}/users/${HANDLE}`;
+	printMessage`    Waiting for server to start at ${serverUrl}...`;
+	if (!await waitForServer(serverUrl, STARTUP_TIMEOUT)) {
+		printErrorMessage`Server did not start within \
+${String(STARTUP_TIMEOUT)}ms`;
+		return false;
+	}
+	printMessage`    Server is ready. Running lookup command...`;
+	try {
+		await runSubCommand([
+			"deno",
+			"task",
+			"cli",
+			"lookup",
+			lookupTarget
+		], { cwd: CWD });
+		return true;
+	} catch (error) {
+		if (error instanceof Error) printErrorMessage`${error.message}`;
+	}
+	return false;
+};
+/**
+* Wait for the server to be ready by checking if it responds to requests.
+*/
+async function waitForServer(url, timeout) {
+	const startTime = Date.now();
+	while (Date.now() - startTime < timeout) {
+		try {
+			if ((await fetch(url, { signal: AbortSignal.timeout(1e3) })).ok) return true;
+		} catch {}
+		await new Promise((resolve) => setTimeout(resolve, 500));
+	}
+	return false;
+}
+async function serverClosure(dir, cmd, callback) {
+	const devCommand = cmd.split(" ");
+	const serverProcess = spawn(devCommand[0], devCommand.slice(1), {
+		cwd: dir,
+		stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		],
+		detached: true
+	});
+	const stdout = createWriteStream(join(dir, "out.txt"), { flags: "a" });
+	const stderr = createWriteStream(join(dir, "err.txt"), { flags: "a" });
+	serverProcess.stdout?.pipe(stdout);
+	serverProcess.stderr?.pipe(stderr);
+	try {
+		return await callback(await determinePort(serverProcess));
+	} finally {
+		try {
+			process.kill(-serverProcess.pid, "SIGKILL");
+		} catch {
+			serverProcess.kill("SIGKILL");
+			stdout.end();
+			stderr.end();
+		}
+	}
+}
+function determinePort(server) {
+	return new Promise((resolve, reject) => {
+		const timeout = setTimeout(() => {
+			reject(/* @__PURE__ */ new Error("Timeout: Could not determine port from server output"));
+		}, STARTUP_TIMEOUT);
+		let stdoutData = "";
+		let stderrData = "";
+		const portPatterns = [
+			/listening on.*:(\d+)/i,
+			/server.*:(\d+)/i,
+			/port\s*:?\s*(\d+)/i,
+			/https?:\/\/localhost:(\d+)/i,
+			/https?:\/\/0\.0\.0\.0:(\d+)/i,
+			/https?:\/\/127\.0\.0\.1:(\d+)/i,
+			/https?:\/\/[^:]+:(\d+)/i
+		];
+		const checkForPort = (data) => {
+			for (const pattern of portPatterns) {
+				const match = data.match(pattern);
+				if (match && match[1]) {
+					const port = Number.parseInt(match[1], 10);
+					if (port > 0 && port < 65536) {
+						clearTimeout(timeout);
+						return port;
+					}
+				}
+			}
+			return null;
+		};
+		server.stdout.on("data", (chunk) => {
+			stdoutData += chunk.toString();
+			const port = checkForPort(stdoutData);
+			if (port) resolve(port);
+		});
+		server.stderr.on("data", (chunk) => {
+			stderrData += chunk.toString();
+			const port = checkForPort(stderrData);
+			if (port) resolve(port);
+		});
+		server.on("error", (err) => {
+			clearTimeout(timeout);
+			reject(err);
+		});
+		server.on("exit", (code) => {
+			clearTimeout(timeout);
+			reject(/* @__PURE__ */ new Error(`Server exited with code ${code} before port could be determined`));
+		});
+	});
+}
+
+//#endregion
+export { runServerAndLookupUser as default };

package/dist/test/mod.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/test/mod.mjs

@@ -0,0 +1,16 @@
+import { testInitCommand } from "../command.mjs";
+import action_default from "./action.mjs";
+import { run } from "@optique/run";
+
+//#region src/test/mod.ts
+async function main() {
+	console.log("Running test-init command...");
+	await action_default(run(testInitCommand, {
+		programName: "fedify-test-init",
+		help: "both"
+	}));
+}
+await main();
+
+//#endregion
+export {  };

package/dist/test/run.mjs

@@ -0,0 +1,22 @@
+import { printMessage } from "../utils.mjs";
+import create_default, { filterOptions, generateTestCases } from "./create.mjs";
+import runServerAndLookupUser from "./lookup.mjs";
+import { always, filter, map, pipe, tap, unless } from "@fxts/core";
+import { optionNames } from "@optique/core";
+import { join as join$1 } from "node:path";
+
+//#region src/test/run.ts
+const runTests = (dry) => ({ testDirPrefix, dryRun, hydRun, ...options }) => pipe(options, printStartMessage(dry), generateTestCases, filter(filterOptions), map(create_default(join$1(testDirPrefix, getMid(dryRun, hydRun, dry)), dry)), Array.fromAsync, unless(always(dry), runServerAndLookupUser));
+var run_default = runTests;
+const printStartMessage = (dry) => tap(() => printMessage`\n
+Init ${dry ? "Dry" : "Hyd"} Test start!
+Options: ${optionNames([
+	"Web Framework",
+	"Package Manager",
+	"KV Store",
+	"Message Queue"
+])}`);
+const getMid = (dryRun, hydRun, dry) => dryRun === hydRun ? dry ? "dry" : "hyd" : "";
+
+//#endregion
+export { run_default as default };

package/dist/test/utils.mjs

@@ -0,0 +1,15 @@
+import { printMessage } from "../utils.mjs";
+import { rm } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+//#region src/test/utils.ts
+const genRunId = () => `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+const genTestDirPrefix = ({ runId }) => join(tmpdir(), "fedify-init", runId);
+const emptyTestDir = ({ testDirPrefix }) => rm(testDirPrefix, { recursive: true }).catch(() => {});
+const logTestDir = ({ runId, testDirPrefix }) => printMessage`Test run completed.
+Run ID: ${runId}
+Path: ${testDirPrefix}`;
+
+//#endregion
+export { emptyTestDir, genRunId, genTestDirPrefix, logTestDir };