refactor(api): ♻️ More OpenAPI refactoring work

This commit is contained in:
Jesse Wierzbinski 2024-09-16 15:29:09 +02:00
parent 6d9e385a04
commit 5aa1c4e625
No known key found for this signature in database
35 changed files with 4883 additions and 1815 deletions

View file

@ -1,4 +1,5 @@
import { apiRoute, applyConfig } from "@/api";
import { createRoute, z } from "@hono/zod-openapi";
import { config } from "~/packages/config-manager";
export const meta = applyConfig({
@ -13,14 +14,34 @@ export const meta = applyConfig({
route: "/.well-known/host-meta",
});
const route = createRoute({
method: "get",
path: "/.well-known/host-meta",
summary: "Well-known host-meta",
responses: {
200: {
description: "Host-meta",
content: {
"application/xrd+xml": {
schema: z.any(),
},
},
},
},
});
export default apiRoute((app) =>
app.on(meta.allowedMethods, meta.route, (context) => {
app.openapi(route, (context) => {
context.header("Content-Type", "application/xrd+xml");
context.status(200);
return context.body(
`<?xml version="1.0" encoding="UTF-8"?><XRD xmlns="http://docs.oasis-open.org/ns/xri/xrd-1.0"><Link rel="lrdd" template="${new URL(
"/.well-known/webfinger",
config.http.base_url,
).toString()}?resource={uri}"/></XRD>`,
);
200,
// biome-ignore lint/suspicious/noExplicitAny: Hono doesn't type this response so this has a TS error, it's joever
) as any;
}),
);

View file

@ -1,4 +1,5 @@
import { apiRoute, applyConfig } from "@/api";
import { createRoute, z } from "@hono/zod-openapi";
import { exportJWK } from "jose";
import { config } from "~/packages/config-manager";
@ -14,8 +15,36 @@ export const meta = applyConfig({
route: "/.well-known/jwks",
});
const route = createRoute({
method: "get",
path: "/.well-known/jwks",
summary: "JWK Set",
responses: {
200: {
description: "JWK Set",
content: {
"application/json": {
schema: z.object({
keys: z.array(
z.object({
kty: z.string(),
use: z.string(),
alg: z.string(),
kid: z.string(),
crv: z.string().optional(),
x: z.string().optional(),
y: z.string().optional(),
}),
),
}),
},
},
},
},
});
export default apiRoute((app) =>
app.on(meta.allowedMethods, meta.route, async (context) => {
app.openapi(route, async (context) => {
const publicKey = await crypto.subtle.importKey(
"spki",
Buffer.from(config.oidc.keys?.public ?? "", "base64"),
@ -29,15 +58,18 @@ export default apiRoute((app) =>
// Remove the private key
jwk.d = undefined;
return context.json({
keys: [
{
...jwk,
use: "sig",
alg: "EdDSA",
kid: "1",
},
],
});
return context.json(
{
keys: [
{
...jwk,
use: "sig",
alg: "EdDSA",
kid: "1",
},
],
},
200,
);
}),
);

View file

@ -1,4 +1,5 @@
import { apiRoute, applyConfig } from "@/api";
import { createRoute, z } from "@hono/zod-openapi";
import manifest from "~/package.json";
export const meta = applyConfig({
@ -13,8 +14,45 @@ export const meta = applyConfig({
route: "/.well-known/nodeinfo/2.0",
});
const route = createRoute({
method: "get",
path: "/.well-known/nodeinfo/2.0",
summary: "Well-known nodeinfo 2.0",
responses: {
200: {
description: "Nodeinfo 2.0",
content: {
"application/json": {
schema: z.object({
version: z.string(),
software: z.object({
name: z.string(),
version: z.string(),
}),
protocols: z.array(z.string()),
services: z.object({
outbound: z.array(z.string()),
inbound: z.array(z.string()),
}),
usage: z.object({
users: z.object({
total: z.number(),
activeMonth: z.number(),
activeHalfyear: z.number(),
}),
localPosts: z.number(),
}),
openRegistrations: z.boolean(),
metadata: z.object({}),
}),
},
},
},
},
});
export default apiRoute((app) =>
app.on(meta.allowedMethods, meta.route, (context) => {
app.openapi(route, (context) => {
return context.json({
version: "2.0",
software: { name: "versia-server", version: manifest.version },

View file

@ -1,4 +1,5 @@
import { apiRoute, applyConfig } from "@/api";
import { createRoute } from "@hono/zod-openapi";
import { config } from "~/packages/config-manager";
export const meta = applyConfig({
@ -13,8 +14,19 @@ export const meta = applyConfig({
route: "/.well-known/nodeinfo",
});
const route = createRoute({
method: "get",
path: "/.well-known/nodeinfo",
summary: "Well-known nodeinfo",
responses: {
301: {
description: "Redirect to 2.0 Nodeinfo",
},
},
});
export default apiRoute((app) =>
app.on(meta.allowedMethods, meta.route, (context) => {
app.openapi(route, (context) => {
return context.redirect(
new URL(
"/.well-known/nodeinfo/2.0",

View file

@ -1,4 +1,5 @@
import { apiRoute, applyConfig } from "@/api";
import { createRoute, z } from "@hono/zod-openapi";
import { config } from "~/packages/config-manager";
export const meta = applyConfig({
@ -13,21 +14,56 @@ export const meta = applyConfig({
route: "/.well-known/openid-configuration",
});
const route = createRoute({
method: "get",
path: "/.well-known/openid-configuration",
summary: "OpenID Configuration",
responses: {
200: {
description: "OpenID Configuration",
content: {
"application/json": {
schema: z.object({
issuer: z.string(),
authorization_endpoint: z.string(),
token_endpoint: z.string(),
userinfo_endpoint: z.string(),
jwks_uri: z.string(),
response_types_supported: z.array(z.string()),
subject_types_supported: z.array(z.string()),
id_token_signing_alg_values_supported: z.array(
z.string(),
),
scopes_supported: z.array(z.string()),
token_endpoint_auth_methods_supported: z.array(
z.string(),
),
claims_supported: z.array(z.string()),
}),
},
},
},
},
});
export default apiRoute((app) =>
app.on(meta.allowedMethods, meta.route, (context) => {
app.openapi(route, (context) => {
const baseUrl = new URL(config.http.base_url);
return context.json({
issuer: baseUrl.origin.toString(),
authorization_endpoint: `${baseUrl.origin}/oauth/authorize`,
token_endpoint: `${baseUrl.origin}/oauth/token`,
userinfo_endpoint: `${baseUrl.origin}/api/v1/accounts/verify_credentials`,
jwks_uri: `${baseUrl.origin}/.well-known/jwks`,
response_types_supported: ["code"],
subject_types_supported: ["public"],
id_token_signing_alg_values_supported: ["EdDSA"],
scopes_supported: ["openid", "profile", "email"],
token_endpoint_auth_methods_supported: ["client_secret_basic"],
claims_supported: ["sub"],
});
return context.json(
{
issuer: baseUrl.origin.toString(),
authorization_endpoint: `${baseUrl.origin}/oauth/authorize`,
token_endpoint: `${baseUrl.origin}/oauth/token`,
userinfo_endpoint: `${baseUrl.origin}/api/v1/accounts/verify_credentials`,
jwks_uri: `${baseUrl.origin}/.well-known/jwks`,
response_types_supported: ["code"],
subject_types_supported: ["public"],
id_token_signing_alg_values_supported: ["EdDSA"],
scopes_supported: ["openid", "profile", "email"],
token_endpoint_auth_methods_supported: ["client_secret_basic"],
claims_supported: ["sub"],
},
200,
);
}),
);

View file

@ -1,8 +1,12 @@
import { apiRoute, applyConfig } from "@/api";
import { urlToContentFormat } from "@/content_types";
import type { InstanceMetadata } from "@versia/federation/types";
import { createRoute } from "@hono/zod-openapi";
import { InstanceMetadata as InstanceMetadataSchema } from "@versia/federation/schemas";
import { asc } from "drizzle-orm";
import { Users } from "~/drizzle/schema";
import pkg from "~/package.json";
import { config } from "~/packages/config-manager";
import { User } from "~/packages/database-interface/user";
export const meta = applyConfig({
allowedMethods: ["GET"],
@ -16,28 +20,52 @@ export const meta = applyConfig({
route: "/.well-known/versia",
});
const route = createRoute({
method: "get",
path: "/.well-known/versia",
summary: "Get instance metadata",
responses: {
200: {
description: "Instance metadata",
content: {
"application/json": {
schema: InstanceMetadataSchema,
},
},
},
},
});
export default apiRoute((app) =>
app.on(meta.allowedMethods, meta.route, (context) => {
return context.json({
type: "InstanceMetadata",
compatibility: {
extensions: ["pub.versia:custom_emojis"],
versions: ["0.4.0"],
app.openapi(route, async (context) => {
// Get date of first user creation
const firstUser = await User.fromSql(undefined, asc(Users.createdAt));
return context.json(
{
type: "InstanceMetadata" as const,
compatibility: {
extensions: ["pub.versia:custom_emojis"],
versions: ["0.4.0"],
},
host: new URL(config.http.base_url).host,
name: config.instance.name,
description: config.instance.description,
public_key: {
key: config.instance.keys.public,
algorithm: "ed25519" as const,
},
software: {
name: "Versia Server",
version: pkg.version,
},
banner: urlToContentFormat(config.instance.banner),
logo: urlToContentFormat(config.instance.logo),
created_at: new Date(
firstUser?.data.createdAt ?? 0,
).toISOString(),
},
host: new URL(config.http.base_url).host,
name: config.instance.name,
description: config.instance.description,
public_key: {
key: config.instance.keys.public,
algorithm: "ed25519",
},
software: {
name: "Versia Server",
version: pkg.version,
},
banner: urlToContentFormat(config.instance.banner),
logo: urlToContentFormat(config.instance.logo),
created_at: "2021-10-01T00:00:00Z",
} satisfies InstanceMetadata);
200,
);
}),
);

View file

@ -1,11 +1,5 @@
import {
apiRoute,
applyConfig,
handleZodError,
idValidator,
webfingerMention,
} from "@/api";
import { zValidator } from "@hono/zod-validator";
import { apiRoute, applyConfig, idValidator, webfingerMention } from "@/api";
import { createRoute } from "@hono/zod-openapi";
import { getLogger } from "@logtape/logtape";
import type { ResponseError } from "@versia/federation";
import { and, eq, isNull } from "drizzle-orm";
@ -14,6 +8,7 @@ import { z } from "zod";
import { Users } from "~/drizzle/schema";
import { config } from "~/packages/config-manager";
import { User } from "~/packages/database-interface/user";
import { ErrorSchema } from "~/types/api";
export const meta = applyConfig({
allowedMethods: ["GET"],
@ -29,86 +24,118 @@ export const meta = applyConfig({
export const schemas = {
query: z.object({
resource: z.string().trim().min(1).max(512).startsWith("acct:"),
resource: z
.string()
.trim()
.min(1)
.max(512)
.startsWith("acct:")
.regex(
webfingerMention,
"Invalid resource (should be acct:(id or username)@domain)",
),
}),
};
const route = createRoute({
method: "get",
path: "/.well-known/webfinger",
summary: "Get user information",
request: {
query: schemas.query,
},
responses: {
200: {
description: "User information",
content: {
"application/json": {
schema: z.object({
subject: z.string(),
links: z.array(
z.object({
rel: z.string(),
type: z.string(),
href: z.string(),
}),
),
}),
},
},
},
404: {
description: "User not found",
content: {
"application/json": {
schema: ErrorSchema,
},
},
},
},
});
export default apiRoute((app) =>
app.on(
meta.allowedMethods,
meta.route,
zValidator("query", schemas.query, handleZodError),
async (context) => {
const { resource } = context.req.valid("query");
app.openapi(route, async (context) => {
const { resource } = context.req.valid("query");
// Check if resource is in the correct format (acct:uuid/username@domain)
if (!resource.match(webfingerMention)) {
return context.json(
{
error: "Invalid resource (should be acct:(id or username)@domain)",
},
400,
);
}
const requestedUser = resource.split("acct:")[1];
const requestedUser = resource.split("acct:")[1];
const host = new URL(config.http.base_url).host;
const host = new URL(config.http.base_url).host;
// Check if user is a local user
if (requestedUser.split("@")[1] !== host) {
return context.json({ error: "User is a remote user" }, 404);
}
// Check if user is a local user
if (requestedUser.split("@")[1] !== host) {
return context.json({ error: "User is a remote user" }, 404);
}
const isUuid = requestedUser.split("@")[0].match(idValidator);
const isUuid = requestedUser.split("@")[0].match(idValidator);
const user = await User.fromSql(
and(
eq(
isUuid ? Users.id : Users.username,
requestedUser.split("@")[0],
),
isNull(Users.instanceId),
const user = await User.fromSql(
and(
eq(
isUuid ? Users.id : Users.username,
requestedUser.split("@")[0],
),
);
isNull(Users.instanceId),
),
);
if (!user) {
return context.json({ error: "User not found" }, 404);
if (!user) {
return context.json({ error: "User not found" }, 404);
}
let activityPubUrl = "";
if (config.federation.bridge.enabled) {
const manager = await User.getFederationRequester();
try {
activityPubUrl = await manager.webFinger(
user.data.username,
new URL(config.http.base_url).host,
"application/activity+json",
config.federation.bridge.url,
);
} catch (e) {
const error = e as ResponseError;
getLogger("federation")
.error`Error from bridge: ${await error.response.data}`;
}
}
let activityPubUrl = "";
if (config.federation.bridge.enabled) {
const manager = await User.getFederationRequester();
try {
activityPubUrl = await manager.webFinger(
user.data.username,
new URL(config.http.base_url).host,
"application/activity+json",
config.federation.bridge.url,
);
} catch (e) {
const error = e as ResponseError;
getLogger("federation")
.error`Error from bridge: ${await error.response.data}`;
}
}
return context.json({
subject: `acct:${
isUuid ? user.id : user.data.username
}@${host}`,
return context.json(
{
subject: `acct:${isUuid ? user.id : user.data.username}@${host}`,
links: [
// Keep the ActivityPub link first, because Misskey only searches
// for the first link with rel="self" and doesn't check the type.
activityPubUrl && {
rel: "self",
type: "application/activity+json",
href: activityPubUrl,
},
activityPubUrl
? {
rel: "self",
type: "application/activity+json",
href: activityPubUrl,
}
: undefined,
{
rel: "self",
type: "application/json",
@ -119,11 +146,18 @@ export default apiRoute((app) =>
},
{
rel: "avatar",
type: lookup(user.getAvatarUrl(config)),
type:
lookup(user.getAvatarUrl(config)) ??
"application/octet-stream",
href: user.getAvatarUrl(config),
},
].filter(Boolean),
});
},
),
].filter(Boolean) as {
rel: string;
type: string;
href: string;
}[],
},
200,
);
}),
);