@fedify/init 2.0.0-dev.0

package/dist/action/templates.mjs

@@ -0,0 +1,55 @@
+import { replace } from "../utils.mjs";
+import { readTemplate } from "../lib.mjs";
+import { entries, join, map, pipe } from "@fxts/core";
+import { toMerged } from "es-toolkit";
+
+//#region src/action/templates.ts
+/**
+* Loads the federation configuration file content from template.
+* Reads the default federation template and replaces placeholders with actual configuration values.
+*
+* @param param0 - Configuration object containing imports, project name, KV store, message queue, and package manager
+* @returns The complete federation configuration file content as a string
+*/
+const loadFederation = ({ imports, projectName, kv, mq, packageManager }) => pipe("defaults/federation.ts", readTemplate, replace(/\/\* imports \*\//, imports), replace(/\/\* logger \*\//, JSON.stringify(projectName)), replace(/\/\* kv \*\//, convertEnv(kv.object, packageManager)), replace(/\/\* queue \*\//, convertEnv(mq.object, packageManager)));
+/**
+* Loads the logging configuration file content from template.
+* Reads the default logging template and replaces the project name placeholder.
+*
+* @param param0 - Destructured object containing the project name
+* @returns The complete logging configuration file content as a string
+*/
+const loadLogging = ({ projectName }) => pipe("defaults/logging.ts", readTemplate, replace(/\/\* project name \*\//, JSON.stringify(projectName)));
+/**
+* Generates import statements for KV store and message queue dependencies.
+* Merges imports from both KV and MQ configurations and creates proper ES module import syntax.
+*
+* @param param0 - Destructured object containing kv and mq configurations
+* @returns A multi-line string containing all necessary import statements
+*/
+const getImports = ({ kv, mq }) => pipe(toMerged(kv.imports, mq.imports), entries, map(([module, { "default": defaultImport = "", ...imports }]) => [
+	module,
+	defaultImport,
+	getAlias(imports)
+]), map(([module, defaultImport, namedImports]) => `import ${[defaultImport, namedImports.length > 0 ? `{ ${namedImports} }` : ""].filter((x) => x.length > 0).join(", ")} from ${JSON.stringify(module)};`), join("\n"));
+/**
+* Converts import mappings to named import string with aliases.
+* Creates proper ES module named import syntax, using aliases when the import name differs from the local name.
+*
+* @param imports - A record mapping import names to their local aliases
+* @returns A comma-separated string of named imports with aliases where needed
+*/
+const getAlias = (imports) => pipe(imports, entries, map(([name, alias]) => name === alias ? name : `${name} as ${alias}`), join(", "));
+const ENV_REG_EXP = /process\.env\.(\w+)/g;
+/**
+* Converts Node.js environment variable access to Deno-compatible syntax when needed.
+* Transforms `process.env.VAR_NAME` to `Deno.env.get("VAR_NAME")` for Deno projects.
+*
+* @param obj - The object string containing potential environment variable references
+* @param pm - The package manager (runtime) being used
+* @returns The converted object string with appropriate environment variable access syntax
+*/
+const convertEnv = (obj, pm) => pm === "deno" && ENV_REG_EXP.test(obj) ? obj.replaceAll(ENV_REG_EXP, (_, g1) => `Deno.env.get("${g1}")`) : obj;
+
+//#endregion
+export { getImports, loadFederation, loadLogging };

package/dist/action/utils.mjs

@@ -0,0 +1,47 @@
+import { join } from "node:path";
+
+//#region src/action/utils.ts
+const isDry = ({ dryRun }) => dryRun;
+const hasCommand = (data) => !!data.initializer.command;
+const isDeno = ({ packageManager }) => packageManager === "deno";
+const joinDir = (dir) => ([filename, content]) => [join(dir, ...filename.split("/")), content];
+/**
+* Stringify an object into a valid `.env` file format.
+* From `@std/dotenv/stringify`.
+*
+* @example Usage
+* ```ts
+* import { stringifyEnvs } from "./utils.ts";
+* import { assertEquals } from "@std/assert";
+*
+* const object = { GREETING: "hello world" };
+* assertEquals(stringifyEnvs(object), "GREETING='hello world'");
+* ```
+*
+* @param object object to be stringified
+* @returns string of object
+*/
+function stringifyEnvs(object) {
+	const lines = [];
+	for (const [key, value] of Object.entries(object)) {
+		let quote;
+		let escapedValue = value ?? "";
+		if (key.startsWith("#")) {
+			console.warn(`key starts with a '#' indicates a comment and is ignored: '${key}'`);
+			continue;
+		} else if (escapedValue.includes("\n") || escapedValue.includes("'")) {
+			escapedValue = escapedValue.replaceAll("\n", "\\n");
+			quote = `"`;
+		} else if (escapedValue.match(/\W/)) quote = "'";
+		if (quote) {
+			escapedValue = escapedValue.replaceAll(quote, `\\${quote}`);
+			escapedValue = `${quote}${escapedValue}${quote}`;
+		}
+		const line = `${key}=${escapedValue}`;
+		lines.push(line);
+	}
+	return lines.join("\n");
+}
+
+//#endregion
+export { hasCommand, isDeno, isDry, joinDir, stringifyEnvs };

package/dist/ask/dir.mjs

@@ -0,0 +1,79 @@
+import { getCwd, getOsType, runSubCommand } from "../utils.mjs";
+import { isDirectoryEmpty, logger } from "../lib.mjs";
+import { identity, pipe, when } from "@fxts/core";
+import { input } from "@inquirer/prompts";
+import { message } from "@optique/core/message";
+import { printError } from "@optique/run";
+import toggle from "inquirer-toggle";
+
+//#region src/ask/dir.ts
+/**
+* Fills in the project directory by prompting the user if not provided.
+* If the directory is not empty, asks the user whether to use it anyway.
+* If the user agrees, offers to move existing contents to trash.
+* Else, recursively prompts for a new directory until a valid one is provided.
+*
+* @param options - Initialization options possibly containing a directory
+* @returns A promise resolving to options with a guaranteed directory
+*/
+const fillDir = async (options) => {
+	const dir = options.dir ?? await askDir(getCwd());
+	return await askIfNonEmpty(dir) ? {
+		...options,
+		dir
+	} : await fillDir(options);
+};
+var dir_default = fillDir;
+const askDir = (cwd) => input({
+	message: "Project directory:",
+	default: cwd
+});
+const askIfNonEmpty = async (dir) => {
+	if (await isDirectoryEmpty(dir)) return true;
+	if (await askNonEmpty(dir)) return await moveDirToTrash(dir);
+	return false;
+};
+const askNonEmpty = (dir) => toggle.default({
+	message: `Directory "${dir}" is not empty.
+Do you want to use it anyway?`,
+	default: false
+});
+const moveDirToTrash = (dir) => pipe(dir, askMoveToTrash, when(identity, moveToTrash(dir)));
+const askMoveToTrash = (dir) => toggle.default({
+	message: `Do you want to move the contents of "${dir}" to the trash?
+If you choose "No", you should choose another directory.`,
+	default: false
+});
+const moveToTrash = (dir) => () => pipe(getOsType(), getTrashCommand, (fn) => fn(dir), (cmd) => runSubCommand(cmd, { stdio: "ignore" }), () => true).catch((e) => {
+	logger.error(e);
+	printError(message`Failed to move ${dir} to trash.
+Please move it manually.`);
+	return false;
+});
+const getTrashCommand = (os) => trashCommands[os] ?? trashCommands.linux;
+const trashCommands = {
+	darwin: (dir) => ["trash", dir],
+	win32: (dir) => [
+		"powershell",
+		"-Command",
+		getPowershellTrashCommand(dir)
+	],
+	linux: (dir) => [
+		"rm",
+		"-rf",
+		dir
+	]
+};
+const getPowershellTrashCommand = (dir) => [
+	"Add-Type",
+	"-AssemblyName",
+	"Microsoft.VisualBasic;",
+	"[Microsoft.VisualBasic.FileIO.FileSystem]::DeleteDirectory('",
+	dir,
+	"',",
+	"'OnlyErrorDialogs',",
+	"'SendToRecycleBin')"
+].join(" ");
+
+//#endregion
+export { dir_default as default };

package/dist/ask/kv.mjs

@@ -0,0 +1,41 @@
+import { printErrorMessage } from "../utils.mjs";
+import { isTest, kvStores } from "../lib.mjs";
+import { KV_STORE } from "../const.mjs";
+import { select } from "@inquirer/prompts";
+import { pipe, tap, throwError, unless, when } from "@fxts/core/index.js";
+
+//#region src/ask/kv.ts
+/**
+* Fills in the key-value store by prompting the user if not provided.
+* Ensures the selected KV store is compatible with the chosen package manager.
+*
+* @param options - Initialization options possibly containing a kvStore and packageManager
+* @returns A promise resolving to options with a guaranteed kvStore
+*/
+const fillKvStore = (options) => pipe(options, when(isKvStoreEmpty, askKvStore), unless(isKvSupportsPm, (opt) => pipe(opt, when(isTest, throwError(unmatchedWhileTesting)), tap(noticeUnmatched), fillKvStore)));
+var kv_default = fillKvStore;
+const isKvStoreEmpty = (options) => !options.kvStore;
+const askKvStore = async (data) => ({
+	...data,
+	kvStore: await select({
+		message: "Choose the key-value store to use",
+		choices: KV_STORE.map(choiceKvStore(data.packageManager))
+	})
+});
+const unmatchedWhileTesting = ({ kvStore: kv, packageManager: pm }) => /* @__PURE__ */ new Error(`Key-value store '${kv}' is not compatible with package manager '${pm}'`);
+const noticeUnmatched = ({ kvStore: kv, packageManager: pm }) => printErrorMessage`Error: Key-value store '${kv}' is not compatible with package manager '${pm}'`;
+const choiceKvStore = (pm) => (kv) => ({
+	name: isKvSupportsPm({
+		kvStore: kv,
+		packageManager: pm
+	}) ? kv : `${kv} (not supported with ${pm})`,
+	value: kv,
+	disabled: !isKvSupportsPm({
+		kvStore: kv,
+		packageManager: pm
+	})
+});
+const isKvSupportsPm = ({ kvStore, packageManager }) => kvStores[kvStore].packageManagers.includes(packageManager);
+
+//#endregion
+export { kv_default as default };

package/dist/ask/mod.mjs

@@ -0,0 +1,13 @@
+import dir_default from "./dir.mjs";
+import kv_default from "./kv.mjs";
+import mq_default from "./mq.mjs";
+import pm_default from "./pm.mjs";
+import wf_default from "./wf.mjs";
+import { pipe } from "@fxts/core";
+
+//#region src/ask/mod.ts
+const askOptions = (options) => pipe(options, dir_default, wf_default, pm_default, mq_default, kv_default);
+var ask_default = askOptions;
+
+//#endregion
+export { ask_default as default };

package/dist/ask/mq.mjs

@@ -0,0 +1,43 @@
+import { printErrorMessage } from "../utils.mjs";
+import { isTest, messageQueues } from "../lib.mjs";
+import { MESSAGE_QUEUE } from "../const.mjs";
+import { select } from "@inquirer/prompts";
+import { pipe, tap, throwError, unless, when } from "@fxts/core/index.js";
+
+//#region src/ask/mq.ts
+/**
+* Fills in the message queue by prompting the user if not provided.
+* Ensures the selected message queue is compatible with the chosen package manager.
+*
+* @param options - Initialization options possibly containing a messageQueue and packageManager
+* @returns A promise resolving to options with a guaranteed messageQueue
+*/
+const fillMessageQueue = (options) => pipe(options, when(isMessageQueueEmpty, askMessageQueue), unless(isMqSupportsPm, (opt) => pipe(opt, when(isTest, throwError(unmatchedWhileTesting)), tap(noticeUnmatched), fillMessageQueue)));
+var mq_default = fillMessageQueue;
+const isMessageQueueEmpty = (options) => !options.messageQueue;
+const askMessageQueue = async (data) => ({
+	...data,
+	messageQueue: await select({
+		message: "Choose the message queue to use",
+		choices: MESSAGE_QUEUE.map(choiceMessageQueue(data.packageManager))
+	})
+});
+const unmatchedWhileTesting = ({ messageQueue: mq, packageManager: pm }) => /* @__PURE__ */ new Error(`Message queue '${mq}' is not compatible with package manager '${pm}'`);
+const noticeUnmatched = ({ messageQueue: mq, packageManager: pm }) => {
+	printErrorMessage`Error: Message queue '${mq}' is not compatible with package manager '${pm}'`;
+};
+const choiceMessageQueue = (packageManager) => (messageQueue) => ({
+	name: isMqSupportsPm({
+		messageQueue,
+		packageManager
+	}) ? messageQueue : `${messageQueue} (not supported with ${packageManager})`,
+	value: messageQueue,
+	disabled: !isMqSupportsPm({
+		messageQueue,
+		packageManager
+	})
+});
+const isMqSupportsPm = ({ messageQueue, packageManager }) => messageQueues[messageQueue].packageManagers.includes(packageManager);
+
+//#endregion
+export { mq_default as default };

package/dist/ask/pm.mjs

@@ -0,0 +1,49 @@
+import { getInstallUrl, isPackageManagerAvailable, kvStores, messageQueues, packageManagers, runtimes } from "../lib.mjs";
+import { PACKAGE_MANAGER } from "../const.mjs";
+import webframeworks_default from "../webframeworks.mjs";
+import { pipe, when } from "@fxts/core";
+import { select } from "@inquirer/prompts";
+import { message } from "@optique/core/message";
+import { print } from "@optique/run";
+
+//#region src/ask/pm.ts
+/**
+* Fills in the package manager by prompting the user if not provided.
+* Ensures the selected package manager is compatible with the chosen web framework.
+* If the selected package manager is not installed, informs the user and prompts again.
+*
+* @param options - Initialization options possibly containing a packageManager and webFramework
+* @returns A promise resolving to options with a guaranteed packageManager
+*/
+const fillPackageManager = async ({ packageManager, ...options }) => {
+	const pm = packageManager ?? await askPackageManager(options.webFramework);
+	if (await isPackageManagerAvailable(pm)) return {
+		...options,
+		packageManager: pm
+	};
+	noticeInstallUrl(pm);
+	return await fillPackageManager(options);
+};
+var pm_default = fillPackageManager;
+const askPackageManager = (wf) => select({
+	message: "Choose the package manager to use",
+	choices: PACKAGE_MANAGER.map(choicePackageManager(wf))
+});
+const choicePackageManager = (wf) => (value) => ({
+	name: isWfSupportsPm(wf, value) ? value : `${value} (not supported with ${webframeworks_default[wf].label})`,
+	value,
+	disabled: !isWfSupportsPm(wf, value)
+});
+const isWfSupportsPm = (wf, pm) => webframeworks_default[wf].packageManagers.includes(pm);
+const noticeInstallUrl = (pm) => {
+	const label = getLabel(pm);
+	const url = getInstallUrl(pm);
+	print(message`  Package manager ${label} is not installed.`);
+	print(message`  You can install it from following link: ${url}`);
+	print(message`  or choose another package manager:`);
+};
+const getLabel = (name) => pipe(name, whenHasLabel(webframeworks_default), whenHasLabel(packageManagers), whenHasLabel(messageQueues), whenHasLabel(kvStores), whenHasLabel(runtimes));
+const whenHasLabel = (desc) => when((name) => name in desc, (name) => desc[name].label);
+
+//#endregion
+export { pm_default as default };

package/dist/ask/wf.mjs

@@ -0,0 +1,26 @@
+import { WEB_FRAMEWORK } from "../const.mjs";
+import webframeworks_default from "../webframeworks.mjs";
+import { select } from "@inquirer/prompts";
+
+//#region src/ask/wf.ts
+/**
+* Fills in the web framework by prompting the user if not provided.
+*
+* @param options - Initialization options possibly containing a webFramework
+* @returns A promise resolving to options with a guaranteed webFramework
+*/
+const fillWebFramework = async (options) => ({
+	...options,
+	webFramework: options.webFramework ?? await askWebFramework()
+});
+var wf_default = fillWebFramework;
+const askWebFramework = () => select({
+	message: "Choose the web framework to use",
+	choices: WEB_FRAMEWORK.map((value) => ({
+		name: webframeworks_default[value].label,
+		value
+	}))
+});
+
+//#endregion
+export { wf_default as default };

package/dist/command.d.mts

@@ -0,0 +1,41 @@
+import * as _optique_core0 from "@optique/core";
+import { InferValue } from "@optique/core";
+
+//#region src/command.d.ts
+declare const initOptions: _optique_core0.Parser<"sync", {
+  readonly dir: string;
+  readonly webFramework: "hono" | "nitro" | "next" | "elysia" | "express";
+  readonly packageManager: "deno" | "pnpm" | "bun" | "yarn" | "npm";
+  readonly kvStore: "denokv" | "redis" | "postgres";
+  readonly messageQueue: "denokv" | "redis" | "postgres" | "amqp";
+  readonly dryRun: boolean;
+  readonly debugOption: {
+    readonly debug: boolean;
+  };
+}, {
+  readonly dir: [_optique_core0.ValueParserResult<string>];
+  readonly webFramework: [_optique_core0.ValueParserResult<"hono" | "nitro" | "next" | "elysia" | "express">];
+  readonly packageManager: [_optique_core0.ValueParserResult<"deno" | "pnpm" | "bun" | "yarn" | "npm">];
+  readonly kvStore: [_optique_core0.ValueParserResult<"denokv" | "redis" | "postgres">];
+  readonly messageQueue: [_optique_core0.ValueParserResult<"denokv" | "redis" | "postgres" | "amqp">];
+  readonly dryRun: _optique_core0.ValueParserResult<boolean>;
+  readonly debugOption: {
+    readonly debug: _optique_core0.ValueParserResult<boolean>;
+  };
+}>;
+declare const initCommand: _optique_core0.Parser<"sync", {
+  readonly dir: string;
+  readonly webFramework: "hono" | "nitro" | "next" | "elysia" | "express";
+  readonly packageManager: "deno" | "pnpm" | "bun" | "yarn" | "npm";
+  readonly kvStore: "denokv" | "redis" | "postgres";
+  readonly messageQueue: "denokv" | "redis" | "postgres" | "amqp";
+  readonly dryRun: boolean;
+  readonly debugOption: {
+    readonly debug: boolean;
+  };
+} & {
+  readonly command: "init";
+}, ["matched", string] | ["parsing", Record<string | symbol, unknown>]>;
+type InitCommand = InferValue<typeof initCommand>;
+//#endregion
+export { InitCommand, initCommand, initOptions };

package/dist/command.mjs

@@ -0,0 +1,44 @@
+import { KV_STORE, MESSAGE_QUEUE, PACKAGE_MANAGER, WEB_FRAMEWORK } from "./const.mjs";
+import { path } from "@optique/run";
+import { argument, choice, command, constant, merge, message, multiple, object, option, optionNames, optional, or } from "@optique/core";
+
+//#region src/command.ts
+const webFramework = optional(option("-w", "--web-framework", choice(WEB_FRAMEWORK, { metavar: "WEB_FRAMEWORK" }), { description: message`The web framework to integrate Fedify with.` }));
+const packageManager = optional(option("-p", "--package-manager", choice(PACKAGE_MANAGER, { metavar: "PACKAGE_MANAGER" }), { description: message`The package manager to use for installing dependencies.` }));
+const kvStore = optional(option("-k", "--kv-store", choice(KV_STORE, { metavar: "KV_STORE" }), { description: message`The key-value store to use for caching and some other features.` }));
+const messageQueue = optional(option("-m", "--message-queue", choice(MESSAGE_QUEUE, { metavar: "MESSAGE_QUEUE" }), { description: message`The message queue to use for background tasks.` }));
+const debugOption = object("Global options", { debug: option("-d", "--debug", { description: message`Enable debug mode.` }) });
+const initOptions = object("Initialization options", {
+	dir: optional(argument(path({ metavar: "DIR" }), { description: message`The project directory to initialize.  If a specified directory does not exist, it will be created.` })),
+	webFramework,
+	packageManager,
+	kvStore,
+	messageQueue,
+	dryRun: option("--dry-run", { description: message`Perform a trial run with no changes made.` }),
+	debugOption
+});
+const initCommand = command("init", merge(initOptions, object({ command: constant("init") })), {
+	brief: message`Initialize a new Fedify project directory.`,
+	description: message`Initialize a new Fedify project directory.
+
+By default, it initializes the current directory.  You can specify a different directory as an argument.
+
+Unless you specify all options (${optionNames(["-w", "--web-framework"])}, ${optionNames(["-p", "--package-manager"])}, ${optionNames(["-k", "--kv-store"])}, and ${optionNames(["-m", "--message-queue"])}), it will prompt you to select the options interactively.`
+});
+const noHydRun = object({ noHydRun: option("--no-hyd-run", { description: message`Log outputs without creating files.` }) });
+const noDryRun = object({ noDryRun: option("--no-dry-run", { description: message`Test with files creations and installations.` }) });
+const testInitCommand = command("test-init", merge(object("Initialization options", {
+	webFramework: multiple(webFramework),
+	packageManager: multiple(packageManager),
+	kvStore: multiple(kvStore),
+	messageQueue: multiple(messageQueue),
+	debugOption
+}), optional(or(noHydRun, noDryRun))), {
+	brief: message`Test an initializing command .`,
+	description: message`Test an initializing command on temporary directories.
+
+Unless you specify all options (${optionNames(["-w", "--web-framework"])}, ${optionNames(["-p", "--package-manager"])}, ${optionNames(["-k", "--kv-store"])}, and ${optionNames(["-m", "--message-queue"])}), it will test all combinations of the options.`
+});
+
+//#endregion
+export { initCommand, initOptions, testInitCommand };

package/dist/const.d.mts

@@ -0,0 +1,4 @@
+//#region src/const.d.ts
+declare const PACKAGE_MANAGER: readonly ["deno", "pnpm", "bun", "yarn", "npm"];
+//#endregion
+export { PACKAGE_MANAGER };

package/dist/const.mjs

@@ -0,0 +1,34 @@
+//#region src/const.ts
+const PACKAGE_MANAGER = [
+	"deno",
+	"pnpm",
+	"bun",
+	"yarn",
+	"npm"
+];
+const WEB_FRAMEWORK = [
+	"hono",
+	"nitro",
+	"next",
+	"elysia",
+	"express"
+];
+const MESSAGE_QUEUE = [
+	"denokv",
+	"redis",
+	"postgres",
+	"amqp"
+];
+const KV_STORE = [
+	"denokv",
+	"redis",
+	"postgres"
+];
+const DB_TO_CHECK = [
+	"redis",
+	"postgres",
+	"amqp"
+];
+
+//#endregion
+export { DB_TO_CHECK, KV_STORE, MESSAGE_QUEUE, PACKAGE_MANAGER, WEB_FRAMEWORK };

package/dist/deno.mjs

@@ -0,0 +1,5 @@
+//#region deno.json
+var version = "2.0.0";
+
+//#endregion
+export { version };

package/dist/json/biome.json

@@ -0,0 +1,14 @@
+{
+  "$schema": "https://biomejs.dev/schemas/1.8.3/schema.json",
+  "organizeImports": {
+    "enabled": true
+  },
+  "formatter": {
+    "enabled": true,
+    "indentStyle": "space",
+    "indentWidth": 2
+  },
+  "linter": {
+    "enabled": false
+  }
+}

package/dist/json/biome.mjs

@@ -0,0 +1,14 @@
+//#region src/json/biome.json
+var biome_default = {
+	$schema: "https://biomejs.dev/schemas/1.8.3/schema.json",
+	organizeImports: { "enabled": true },
+	formatter: {
+		"enabled": true,
+		"indentStyle": "space",
+		"indentWidth": 2
+	},
+	linter: { "enabled": false }
+};
+
+//#endregion
+export { biome_default as default };

package/dist/json/db-to-check.json

@@ -0,0 +1,17 @@
+{
+  "redis": {
+    "name": "Redis",
+    "defaultPort": 6379,
+    "documentation": "https://redis.io/docs/latest/operate/oss_and_stack/install/archive/install-redis/"
+  },
+  "postgres": {
+    "name": "PostgreSQL",
+    "defaultPort": 5432,
+    "documentation": "https://www.postgresql.org/download/"
+  },
+  "amqp": {
+    "name": "RabbitMQ",
+    "defaultPort": 5672,
+    "documentation": "https://www.rabbitmq.com/docs/download"
+  }
+}

package/dist/json/db-to-check.mjs

@@ -0,0 +1,21 @@
+//#region src/json/db-to-check.json
+var db_to_check_default = {
+	redis: {
+		"name": "Redis",
+		"defaultPort": 6379,
+		"documentation": "https://redis.io/docs/latest/operate/oss_and_stack/install/archive/install-redis/"
+	},
+	postgres: {
+		"name": "PostgreSQL",
+		"defaultPort": 5432,
+		"documentation": "https://www.postgresql.org/download/"
+	},
+	amqp: {
+		"name": "RabbitMQ",
+		"defaultPort": 5672,
+		"documentation": "https://www.rabbitmq.com/docs/download"
+	}
+};
+
+//#endregion
+export { db_to_check_default as default };

package/dist/json/kv.json

@@ -0,0 +1,39 @@
+{
+  "redis": {
+    "label": "Redis",
+    "packageManagers": ["deno", "bun", "npm", "yarn", "pnpm"],
+    "dependencies": {
+      "npm:ioredis": "^5.4.1"
+    },
+    "imports": {
+      "@fedify/redis": { "RedisKvStore": "RedisKvStore" },
+      "ioredis": { "Redis": "Redis" }
+    },
+    "object": "new RedisKvStore(new Redis(process.env.REDIS_URL))",
+    "env": {
+      "REDIS_URL": "redis://localhost:6379"
+    }
+  },
+  "postgres": {
+    "label": "PostgreSQL",
+    "packageManagers": ["deno", "bun", "npm", "yarn", "pnpm"],
+    "dependencies": {
+      "npm:postgres": "^3.4.5"
+    },
+    "imports": {
+      "@fedify/postgres": { "PostgresKvStore": "PostgresKvStore" },
+      "postgres": { "default": "postgres" }
+    },
+    "object": "new PostgresKvStore(postgres(process.env.POSTGRES_URL))",
+    "env": {
+      "POSTGRES_URL": "postgres://postgres@localhost:5432/postgres"
+    }
+  },
+  "denokv": {
+    "label": "Deno KV",
+    "packageManagers": ["deno"],
+    "imports": { "@fedify/denokv": { "DenoKvStore": "DenoKvStore" } },
+    "object": "new DenoKvStore(await Deno.openKv())",
+    "denoUnstable": ["kv"]
+  }
+}

package/dist/json/kv.mjs

@@ -0,0 +1,47 @@
+//#region src/json/kv.json
+var kv_default = {
+	redis: {
+		"label": "Redis",
+		"packageManagers": [
+			"deno",
+			"bun",
+			"npm",
+			"yarn",
+			"pnpm"
+		],
+		"dependencies": { "npm:ioredis": "^5.4.1" },
+		"imports": {
+			"@fedify/redis": { "RedisKvStore": "RedisKvStore" },
+			"ioredis": { "Redis": "Redis" }
+		},
+		"object": "new RedisKvStore(new Redis(process.env.REDIS_URL))",
+		"env": { "REDIS_URL": "redis://localhost:6379" }
+	},
+	postgres: {
+		"label": "PostgreSQL",
+		"packageManagers": [
+			"deno",
+			"bun",
+			"npm",
+			"yarn",
+			"pnpm"
+		],
+		"dependencies": { "npm:postgres": "^3.4.5" },
+		"imports": {
+			"@fedify/postgres": { "PostgresKvStore": "PostgresKvStore" },
+			"postgres": { "default": "postgres" }
+		},
+		"object": "new PostgresKvStore(postgres(process.env.POSTGRES_URL))",
+		"env": { "POSTGRES_URL": "postgres://postgres@localhost:5432/postgres" }
+	},
+	denokv: {
+		"label": "Deno KV",
+		"packageManagers": ["deno"],
+		"imports": { "@fedify/denokv": { "DenoKvStore": "DenoKvStore" } },
+		"object": "new DenoKvStore(await Deno.openKv())",
+		"denoUnstable": ["kv"]
+	}
+};
+
+//#endregion
+export { kv_default as default };