rudeshark.net/packages/backend/src/server/index.ts
2023-02-10 00:38:39 +01:00

220 lines
5.1 KiB
TypeScript

/**
* Core Server
*/
import cluster from "node:cluster";
import * as fs from "node:fs";
import * as http from "node:http";
import Koa from "koa";
import Router from "@koa/router";
import mount from "koa-mount";
import koaLogger from "koa-logger";
import * as slow from "koa-slow";
import { IsNull } from "typeorm";
import config from "@/config/index.js";
import Logger from "@/services/logger.js";
import { UserProfiles, Users } from "@/models/index.js";
import { genIdenticon } from "@/misc/gen-identicon.js";
import { createTemp } from "@/misc/create-temp.js";
import { publishMainStream } from "@/services/stream.js";
import * as Acct from "@/misc/acct.js";
import { envOption } from "@/env.js";
import { koaBody } from 'koa-body';
import megalodon, { MegalodonInterface } from '@cutls/megalodon';
import activityPub from "./activitypub.js";
import nodeinfo from "./nodeinfo.js";
import wellKnown from "./well-known.js";
import apiServer from "./api/index.js";
import fileServer from "./file/index.js";
import proxyServer from "./proxy/index.js";
import webServer from "./web/index.js";
import { initializeStreamingServer } from "./api/streaming.js";
export const serverLogger = new Logger("server", "gray", false);
// Init app
const app = new Koa();
app.proxy = true;
if (!["production", "test"].includes(process.env.NODE_ENV || "")) {
// Logger
app.use(
koaLogger((str) => {
serverLogger.info(str);
}),
);
// Delay
if (envOption.slow) {
app.use(
slow({
delay: 3000,
}),
);
}
}
// HSTS
// 6months (15552000sec)
if (config.url.startsWith("https") && !config.disableHsts) {
app.use(async (ctx, next) => {
ctx.set("strict-transport-security", "max-age=15552000; preload");
await next();
});
}
app.use(mount("/api", apiServer));
app.use(mount("/files", fileServer));
app.use(mount("/proxy", proxyServer));
// Init router
const router = new Router();
// Routing
router.use(activityPub.routes());
router.use(nodeinfo.routes());
router.use(wellKnown.routes());
router.get("/avatar/@:acct", async (ctx) => {
const { username, host } = Acct.parse(ctx.params.acct);
const user = await Users.findOne({
where: {
usernameLower: username.toLowerCase(),
host: host == null || host === config.host ? IsNull() : host,
isSuspended: false,
},
relations: ["avatar"],
});
if (user) {
ctx.redirect(Users.getAvatarUrlSync(user));
} else {
ctx.redirect("/static-assets/user-unknown.png");
}
});
router.get("/identicon/:x", async (ctx) => {
const [temp, cleanup] = await createTemp();
await genIdenticon(ctx.params.x, fs.createWriteStream(temp));
ctx.set("Content-Type", "image/png");
ctx.body = fs.createReadStream(temp).on("close", () => cleanup());
});
router.get("/verify-email/:code", async (ctx) => {
const profile = await UserProfiles.findOneBy({
emailVerifyCode: ctx.params.code,
});
if (profile != null) {
ctx.body = "Verify succeeded!";
ctx.status = 200;
await UserProfiles.update(
{ userId: profile.userId },
{
emailVerified: true,
emailVerifyCode: null,
},
);
publishMainStream(
profile.userId,
"meUpdated",
await Users.pack(
profile.userId,
{ id: profile.userId },
{
detail: true,
includeSecrets: true,
},
),
);
} else {
ctx.status = 404;
}
});
router.get("/oauth/authorize", async (ctx) => {
const client_id = ctx.request.query.client_id;
console.log(ctx.request.req);
ctx.redirect(Buffer.from(client_id?.toString() || '', 'base64').toString());
});
router.get("/oauth/token", koaBody(), async (ctx) => {
const body: any = ctx.request.body;
const BASE_URL = `${ctx.request.protocol}://${ctx.request.hostname}`;
const generator = (megalodon as any).default;
const client = generator('misskey', BASE_URL, null) as MegalodonInterface;
const m = body.code.match(/^[a-zA-Z0-9-]+/);
if (!m.length) return { error: 'Invalid code' }
try {
const atData = await client.fetchAccessToken(null, body.client_secret, m[0]);
ctx.body = {
access_token: atData.accessToken,
token_type: 'Bearer',
scope: 'read write follow',
created_at: new Date().getTime() / 1000
};
} catch (err: any) {
console.error(err);
ctx.status = 401;
ctx.body = err.response.data;
}
});
// Register router
app.use(router.routes());
app.use(mount(webServer));
function createServer() {
return http.createServer(app.callback());
}
// For testing
export const startServer = () => {
const server = createServer();
initializeStreamingServer(server);
server.listen(config.port);
return server;
};
export default () =>
new Promise((resolve) => {
const server = createServer();
initializeStreamingServer(server);
server.on("error", (e) => {
switch ((e as any).code) {
case "EACCES":
serverLogger.error(
`You do not have permission to listen on port ${config.port}.`,
);
break;
case "EADDRINUSE":
serverLogger.error(
`Port ${config.port} is already in use by another process.`,
);
break;
default:
serverLogger.error(e);
break;
}
if (cluster.isWorker) {
process.send!("listenFailed");
} else {
// disableClustering
process.exit(1);
}
});
// @ts-ignore
server.listen(config.port, resolve);
});