Use en dash in "key–value" throughout codebase

 -  Fedify is now available on npm: [@fedify/fedify].  [[#24]]

 -  Abstract key-value store for caching.

 -  Abstract key–value store for caching.

     -  Added `KvStore` interface.

     -  Added `KvStoreSetOptions` interface.

  )

  .option(

    "-k, --kv-store <kv-store:kv-store>",

    "Choose the key-value store to use for caching.",

    "Choose the key–value store to use for caching.",

  )

  .option(

    "-q, --message-queue <message-queue:message-queue>",

        dinosaurDrawn = true;

      }

      kvStore = await Select.prompt({

        message: "Choose the key-value store to use for caching",

        message: "Choose the key–value store to use for caching",

        options: [

          { name: "In-memory", value: null },

          ...Object.entries(kvStores).map(([value, { label, runtimes }]) => ({

    }

    logger.debug(

      "Runtime: {runtime}; package manager: {packageManager}; " +

        "web framework: {webFramework}; key-value store: {kvStore}; " +

        "web framework: {webFramework}; key–value store: {kvStore}; " +

        "message queue: {messageQueue}",

      {

        runtime,

 -  Package manager (if Node.js): [npm], [pnpm], or [Yarn]

 -  Web framework: Bare-bones, [Fresh] (if Deno), [Hono], [Express] (unless

    Deno), or [Nitro] (unless Deno)

 -  Key-value store: In-memory, [Redis], [PostgreSQL], or [Deno KV] (if Deno)

 -  key–value store: In-memory, [Redis], [PostgreSQL], or [Deno KV] (if Deno)

 -  Message queue: In-memory, [Redis], [PostgreSQL], [AMQP] (e.g., [RabbitMQ]),

    or [Deno KV] (if Deno)

If it's omitted, no web framework will be integrated.

### `-k`/`--kv-store`: Key-value store

### `-k`/`--kv-store`: key–value store

You can specify the key-value store to use by using the `-k`/`--kv-store`

You can specify the key–value store to use by using the `-k`/`--kv-store`

option.  The available options are:

 -  `redis`: [Redis]

 -  `postgres`: [PostgreSQL]

 -  `denokv`: [Deno KV] (if Deno)

If it's omitted, the in-memory key-value store (which is for development

If it's omitted, the in-memory key–value store (which is for development

purpose) will be used.

### `-q`/`--message-queue`: Message queue

that the `Federation` object uses to store several kinds of cache data and

to maintain the queue of outgoing activities.

`KvStore` is an abstract interface that represents a key-value store.

`KvStore` is an abstract interface that represents a key–value store.

For now, Fedify provides two built-in implementations of `KvStore`, which are

`MemoryKvStore` and `DenoKvStore` classes.  The `MemoryKvStore` class is for

testing and development purposes, and the `DenoKvStore` class is Deno KV-backed

Usually, you don't need to set this property because the default document

loader is sufficient for most cases.  The default document loader

caches the loaded documents in the key-value store.

caches the loaded documents in the key–value store.

See the

[*Getting a `DocumentLoader`* section](./context.md#getting-a-documentloader)

Usually, you don't need to set this property because the default document

loader factory is sufficient for most cases.  The default document loader

factory intentionally doesn't cache the loaded documents in the key-value

factory intentionally doesn't cache the loaded documents in the key–value

store.

See the [*Getting an authenticated `DocumentLoader`*

In the above code, we import the `createFederation()` function from the Fedify

framework to create a new `Federation` object.  We pass an object to the

`createFederation()` function, which is the configuration object.

The `kv` property is a key-value store that is used to store several internal

The `kv` property is a key–value store that is used to store several internal

data of the `Federation` object.  We use the `MemoryKvStore` to open

a key-value store.

a key–value store.

> [!IMPORTANT]

> Since `MemoryKvStore` is for testing and development purposes, you should

> use a persistent key-value store like `DenoKvStore` (in Deno) or

> use a persistent key–value store like `DenoKvStore` (in Deno) or

> [`RedisKvStore`] (from [@fedify/redis] package) or [`PostgresKvStore`]

> (from [@fedify/postgres] package) for production use.

>

By the way, when should we generate a key pair?  In general, you should generate

a key pair when the actor is created.  In our case, we generate a key pair when

the actor *me* is dispatched for the first time.  Then, we store the key pair

in the key-value store so that the server can use the key pair later.

in the key–value store so that the server can use the key pair later.

The `~ActorCallbackSetters.setKeyPairsDispatcher()` method is used to set a key

pairs dispatcher for the actor.  The key pairs dispatcher is a function that is

} from "@fedify/fedify";

const federation = null as unknown as Federation<void>;

// ---cut-before---

const kv = await Deno.openKv();  // Open the key-value store

const kv = await Deno.openKv();  // Open the key–value store

federation

  .setActorDispatcher("/users/{identifier}", async (ctx, identifier) => {

import { serialize as encodeV8, deserialize as decodeV8 } from "node:v8";

import { openKv } from "@deno/kv";

// Open the key-value store:

// Open the key–value store:

const kv = await openKv("kv.db", { encodeV8, decodeV8 });

federation

// ---cut-before---

import { openKv } from "@deno/kv";

const kv = await openKv("kv.db");  // Open the key-value store

const kv = await openKv("kv.db");  // Open the key–value store

federation

  .setActorDispatcher("/users/{identifier}", async (ctx, identifier) => {

dispatcher is called when the key pairs of an actor is needed. The key pairs

dispatcher should return an array of objects that contain the private key

and the public key of the actor.  In this case, we generate a new key pair

at the first time and store it in the key-value store.  When the actor *me* is

dispatched again, the key pairs dispatcher loads the key pair from the key-value

at the first time and store it in the key–value store.  When the actor *me* is

dispatched again, the key pairs dispatcher loads the key pair from the key–value

store.

> [!NOTE]

> Although we use the Deno KV database in this tutorial, you can use any

> other your favorite database to store the key pair.  The key-value store

> other your favorite database to store the key pair.  The key–value store

> is just an example.

Restart the server and make an HTTP request to the actor *me* using `curl`.

-----------------

The server should list the actor's followers on the home page.  To do this,

we need to store the followers in the key-value store.  We will store each

we need to store the followers in the key–value store.  We will store each

`Follow` activity's ID as the key and the follower's actor ID as the value:

~~~~ typescript{16-17} twoslash [server.ts]

      follower,

      new Accept({ actor: follow.objectId, object: follow }),

    );

    // Store the follower in the key-value store:

    // Store the follower in the key–value store:

    await kv.set(["followers", follow.id.href], follow.actorId.href);

  });

~~~~

:::

The above code lists the actor's followers on the home page.  The followers are

stored in the key-value store, and we retrieve the followers from the key-value

stored in the key–value store, and we retrieve the followers from the key–value

store and display them on the home page.

Restart the server and navigate to the home page in your web browser.  You

---------

 -  Implement unfollowing feature: Listen to the `Undo` activity and remove

    the follower from the key-value store when the server receives an `Undo`

    the follower from the key–value store when the server receives an `Undo`

    activity.

 -  Integration with a web framework: In the above example, we hard-coded