Add actors table and actor GraphQL API

.oxlintrc.json

@@ -24,9 +24,9 @@
       { "ignoreConsecutiveComments": true }
     ],
     "eslint/curly": ["error", "multi-line"],
-    "node/no-top-level-await": "off",
     "oxc/no-optional-chaining": "off",
     "oxc/no-async-await": "off",
+    "jsdoc/require-param": "off",
     "eslint/eqeqeq": ["off", "smart"],
     "eslint/func-style": ["off"],
     "eslint/max-lines-per-function": "off",
@@ -42,6 +42,7 @@
     "eslint/no-eq-null": "off",
     "eslint/no-magic-numbers": "off",
     "eslint/no-ternary": "off",
+    "eslint/no-negated-condition": "off",
     "eslint/no-nested-ternary": "off",
     "eslint/no-undefined": "off",
     "eslint/no-void": "off",

mise.toml

@@ -7,6 +7,7 @@ experimental = true
 "aqua:dahlia/hongdown" = "0.4.3"
 "github:nushell/nushell" = "0.114.1"
 node = "26"
+"npm:@fedify/cli" = "2.4.0-dev.1758"
 "npm:oxlint" = "1.75.0"
 "npm:oxlint-tsgolint" = "7.0.2001"
 "npm:pglite-cli" = "0.0.1"

packages/drfed/package.json

@@ -62,24 +62,26 @@
   "devDependencies": {
     "@logtape/testing-node": "catalog:",
     "@types/node": "catalog:",
-    "@types/pg": "catalog:",
     "tsdown": "catalog:",
     "typescript": "catalog:"
   },
   "dependencies": {
     "@drfed/graphql": "workspace:*",
     "@drfed/models": "workspace:*",
     "@electric-sql/pglite": "catalog:",
+    "@fedify/fedify": "catalog:",
+    "@fedify/pglite": "catalog:",
+    "@fedify/postgres": "catalog:",
     "@logtape/drizzle-orm": "catalog:",
     "@logtape/logtape": "catalog:",
     "@optique/core": "catalog:",
     "@optique/logtape": "catalog:",
     "@optique/run": "catalog:",
-    "@upyo/smtp": "catalog:",
     "@upyo/logtape": "catalog:",
+    "@upyo/smtp": "catalog:",
     "drizzle-orm": "catalog:",
     "graphql": "catalog:",
-    "pg": "catalog:",
+    "postgres": "catalog:",
     "srvx": "^0.11.16"
   }
 }

packages/drfed/src/index.ts

@@ -18,16 +18,18 @@ import { writeFile } from "node:fs/promises";
 import process from "node:process";
 
 import { createYogaServer } from "@drfed/graphql";
+import createFederation from "@drfed/graphql/federation";
 import { schema } from "@drfed/graphql/schema";
 import { migrate } from "@drfed/models";
+import { PgliteKvStore } from "@fedify/pglite";
+import { PostgresKvStore } from "@fedify/postgres";
 import { configure, getConsoleSink } from "@logtape/logtape";
 import { createLoggingConfig } from "@optique/logtape";
 import { run } from "@optique/run";
 import { SmtpTransport } from "@upyo/smtp";
 import { printSchema } from "graphql";
 import { serve } from "srvx";
 
-// oxlint-disable-next-line import/no-relative-parent-imports
 import metadata from "../package.json" with { type: "json" };
 import type {
   Options,
@@ -38,16 +40,26 @@ import program from "./program.ts";
 import seedData from "./seed.ts";
 
 async function runServer(options: ServerOptions) {
-  if (options.drizzle.migrate) {
-    await migrate({ credentials: options.drizzle.credentials });
-  }
-  if (options.seed) {
-    await seedData(options.drizzle.db);
-  }
+  const { credentials } = options.drizzle;
+  if (options.drizzle.migrate) await migrate({ credentials });
+  if (options.seed) await seedData(options.drizzle.db);
+  const kv =
+    "driver" in credentials
+      ? new PgliteKvStore(credentials.client)
+      : new PostgresKvStore(credentials.client);
+  const federation = await createFederation(options.drizzle.db, { kv });
   const { mailer, root } = options;
-  const yogaServer = createYogaServer(options.drizzle.db, { root, mailer });
+  const yogaServer = createYogaServer(options.drizzle.db, federation, {
+    root,
+    mailer,
+  });
   const server = serve({
-    fetch: yogaServer.fetch.bind(yogaServer),
+    fetch: (req) =>
+      federation.fetch(req, {
+        onNotFound: yogaServer.fetch,
+        onNotAcceptable: yogaServer.fetch,
+        contextData: undefined,
+      }),
     hostname: options.address.host,
     manual: true,
     port: options.address.port,
@@ -56,8 +68,13 @@ async function runServer(options: ServerOptions) {
     if (mailer instanceof SmtpTransport) {
       mailer.closeAllConnections();
     }
-    // oxlint-disable-next-line promise/catch-or-return promise/prefer-await-to-then no-magic-numbers
-    server.close().then(() => process.exit(0));
+    // oxlint-disable-next-line promise/catch-or-return promise/prefer-await-to-then
+    server.close().then(async () => {
+      await ("driver" in credentials
+        ? credentials.client.close()
+        : credentials.client.end());
+      process.exit(0);
+    });
   }
   process.once("SIGINT", shutdown);
   process.once("SIGTERM", shutdown);

packages/drfed/src/parser.ts

@@ -27,8 +27,9 @@ import { loggingOptions } from "@optique/logtape";
 import { path } from "@optique/run/valueparser";
 import { LogTapeTransport } from "@upyo/logtape";
 import { SmtpTransport } from "@upyo/smtp";
-import { drizzle as drizzlePostgres } from "drizzle-orm/node-postgres";
 import { drizzle as drizzlePglite } from "drizzle-orm/pglite";
+import { drizzle as drizzlePostgres } from "drizzle-orm/postgres-js";
+import postgres from "postgres";
 
 const pgliteParser = map(
   option(
@@ -67,19 +68,20 @@ const postgresParser = map(
       description: message`The URL of the PostgreSQL database to connect to.  Mutually exclusive with ${optionNames(["--pglite-data-path", "--data-path", "-d"])}.`,
     },
   ),
-  (dbUrl) => ({
-    credentials: {
-      url: dbUrl.href,
-    },
-    db: drizzlePostgres({
-      connection: {
-        connectionString: dbUrl.href,
+  (dbUrl) => {
+    const client = postgres(dbUrl.href);
+    return {
+      credentials: {
+        client,
       },
-      relations,
-      schema,
-      logger: getLogger(),
-    }),
-  }),
+      db: drizzlePostgres({
+        client,
+        relations,
+        schema,
+        logger: getLogger(),
+      }),
+    };
+  },
 );
 
 const smtpParser = map(

packages/graphql/README.md

@@ -24,10 +24,18 @@ Usage
 
 ~~~~ ts
 import { createYogaServer } from "@drfed/graphql";
-
-const yoga = createYogaServer(db);
-serve({ fetch: yoga.fetch.bind(yoga) });
+import createFederation from "@drfed/graphql/federation";
+
+const federation = await createFederation(db, { kv });
+const yoga = createYogaServer(db, federation);
+serve({
+  fetch: (request) =>
+    federation.fetch(request, { onNotFound: yoga.fetch, contextData: undefined }),
+});
 ~~~~
 
-`createYogaServer` accepts a Drizzle database instance and returns a
-GraphQL Yoga server ready to handle HTTP requests.
+`createFederation` builds a Fedify `Federation` with every DrFed dispatcher
+registered.  `createYogaServer` accepts a Drizzle database instance, that
+federation, and optional server options, and returns a GraphQL Yoga server
+ready to handle HTTP requests.  The federation is stored in the resolver
+context as is; `createYogaServer` never registers anything on it.

packages/graphql/package.json

@@ -50,10 +50,18 @@
       "types": "./dist/account.d.mts",
       "default": "./dist/account.mjs"
     },
+    "./actor": {
+      "types": "./dist/actor.d.mts",
+      "default": "./dist/actor.mjs"
+    },
     "./builder": {
       "types": "./dist/builder.d.mts",
       "default": "./dist/builder.mjs"
     },
+    "./federation": {
+      "types": "./dist/federation.d.mts",
+      "default": "./dist/federation.mjs"
+    },
     "./instance": {
       "types": "./dist/instance.d.mts",
       "default": "./dist/instance.mjs"
@@ -71,7 +79,9 @@
     "entry": [
       "src/index.ts",
       "src/account.ts",
+      "src/actor.ts",
       "src/builder.ts",
+      "src/federation.ts",
       "src/instance.ts",
       "src/schema.ts"
     ],
@@ -95,6 +105,8 @@
   "dependencies": {
     "@drfed/models": "workspace:*",
     "@fedify/uri-template": "^2.3.1",
+    "@fedify/fedify": "catalog:",
+    "@fedify/vocab": "catalog:",
     "@logtape/graphql-yoga": "catalog:",
     "@logtape/logtape": "catalog:",
     "@pothos/core": "^4.13.0",

packages/graphql/src/account.ts

@@ -18,7 +18,6 @@ import { drizzleConnectionHelpers } from "@pothos/plugin-drizzle";
 import { and, eq, isNotNull } from "drizzle-orm/sql/expressions";
 
 import builder, { type DrFedObjectRef } from "./builder.ts";
-// oxlint-disable-next-line import/no-cycle
 import { Instance } from "./instance.ts";
 
 /**
@@ -204,3 +203,100 @@ builder.queryFields((t) => ({
     type: AccountRef,
   }),
 }));
+
+const instanceMembersConnection = drizzleConnectionHelpers(
+  builder,
+  "instanceMembers",
+  {
+    query: {
+      orderBy: { created: "desc" },
+    },
+    select(nestedSelection) {
+      return {
+        with: {
+          account: nestedSelection(),
+        },
+        where: {
+          accepted: { isNotNull: true },
+        },
+      };
+    },
+    resolveNode(instanceMember) {
+      return instanceMember.account;
+    },
+  },
+);
+
+builder.drizzleObjectField("instances", "members", (t) =>
+  t.connection(
+    {
+      type: Account,
+      description: "The `Account`s that belong to the `Instance`.",
+      select(args, ctx, nestedSelection) {
+        return {
+          with: {
+            instanceMembers: instanceMembersConnection.getQuery(
+              args,
+              ctx,
+              nestedSelection,
+            ),
+          },
+        };
+      },
+      resolve(instance, args, ctx) {
+        return {
+          ...instanceMembersConnection.resolve(
+            instance.instanceMembers,
+            args,
+            ctx,
+            instance,
+          ),
+          totalCount() {
+            return ctx.db.$count(
+              instanceMembers,
+              and(
+                eq(instanceMembers.instanceId, instance.id),
+                isNotNull(instanceMembers.accepted),
+              ),
+            );
+          },
+        };
+      },
+    },
+    {
+      fields(fb) {
+        return {
+          totalCount: fb.int({
+            description:
+              "The total number of `Account`s that belong to the `Instance`. " +
+              "Note that pending members are not counted.",
+            resolve(connection) {
+              return connection.totalCount();
+            },
+          }),
+        };
+      },
+    },
+    {
+      fields(fb) {
+        return {
+          created: fb.expose("created", {
+            type: "DateTime",
+            description:
+              "The date/time when the `Account` was added to the `Instance`.",
+          }),
+          accepted: fb.expose("accepted", {
+            type: "DateTime",
+            nullable: true,
+            description:
+              "The date/time when the `Account` accepted membership in the `Instance`.",
+          }),
+          admin: fb.exposeBoolean("admin", {
+            description:
+              "Whether the `Account` has administrator privileges in the `Instance`.",
+          }),
+        };
+      },
+    },
+  ),
+);