| import { Elysia } from "elysia"; |
| import { logger } from "@chneau/elysia-logger"; |
| import { cors } from "@elysiajs/cors"; |
| import { dlV1Router } from "./sub-router/showtime"; |
| import { FfmpegV2Router } from "./sub-router/probe"; |
| import { IS_GH, NS_runtime } from "@x/types/env.runtime"; |
| import { NS_Misc } from "@x/core/client/misc.ts"; |
| import { NS_error } from "@x/core/client/error.ts"; |
| import { NS_routes_elysia } from "@x/core/server/routes-elysia.ts"; |
| import { start_mongo_db } from "@x/db1/init"; |
| import { ProximaRouter } from "@x/post-process/proxima"; |
| import { CheckRouter } from "./sub-router/check"; |
| import { ProxyDBRouter } from "@x/db1/routes/proxy.ts"; |
| import { filmDBRouter } from "@x/db1/routes/film.ts"; |
| import { bucketDBRouter } from "@x/db1/routes/bucket.ts"; |
| import { UserDBRouter } from "@x/db2/routes/index.ts"; |
| import { BucketRouter } from "./sub-router/bucket"; |
| import { StreamRouter } from "./sub-router/stream"; |
| import { NS_server_stats } from "./lib/cpu"; |
| import { proximaRouter } from "./sub-router/proxima"; |
| import { NS_websockets } from "@x/ff-dl/ws"; |
|
|
| await NS_runtime.set_env_var_db(); |
|
|
| await start_mongo_db(); |
|
|
| const APP_ENV = () => NS_runtime.ENV_VAR_DB?.APP_ENV || process?.env?.APP_ENV; |
|
|
| const APP_ORIGIN = () => |
| NS_runtime.ENV_VAR_DB?.APP_ORIGIN || process?.env?.APP_ORIGIN; |
|
|
| const REPO_ORIGIN = () => |
| NS_runtime.ENV_VAR_DB?.REPO_ORIGIN || process.env.REPO_ORIGIN; |
|
|
| const PORT = process.env.PORT || 7860; |
|
|
| const app = new Elysia() |
|
|
| .use( |
| cors({ |
| origin: "*", |
| allowedHeaders: "*", |
| methods: ["GET", "POST", "PUT", "DELETE", "OPTIONS", "HEAD"], |
| exposeHeaders: "*" |
| }) as any |
| ) |
|
|
| .derive((ctx: any) => ({ |
| publicOrigin: NS_routes_elysia.F_public_origin(ctx) |
| })) |
|
|
| .use(logger()) |
|
|
| .onRequest(({ request }) => { |
| const url = new URL(request.url); |
|
|
| url.pathname = url.pathname |
| .split("/") |
| .map((segment) => segment.replace(/\.$/, "")) |
| .join("/"); |
|
|
| const params = new URLSearchParams(); |
|
|
| for (const [key, value] of url.searchParams) { |
| params.append(key.replace(/\.$/, ""), value.replace(/\.$/, "")); |
| } |
|
|
| url.search = params.toString(); |
|
|
| if (url.href !== request.url) { |
| return new Response(null, { |
| status: 308, |
| headers: { |
| Location: url.href |
| } |
| }); |
| } |
| }) |
|
|
| .onError(async ({ code, error }) => { |
| let e_message = ""; |
| if (code === "VALIDATION") { |
| e_message = error.message; |
| try { |
| e_message = JSON.parse(e_message).summary; |
| } catch (err) {} |
| } |
|
|
| const err_d = NS_error.F_collect_error_status_n_message({ |
| ERR: error |
| }); |
|
|
| NS_Misc.console.error({ |
| ENV: IS_GH() ? "all" : "dev", |
| _browser: false, |
| _log: ["\n"] |
| }); |
| NS_Misc.console.error({ |
| ENV: IS_GH() ? "all" : "dev", |
| _browser: false, |
| _log: [{ code, e_message, ...err_d }, "\n"] |
| }); |
|
|
| return new Response(err_d.message, { |
| status: err_d.status, |
| headers: { |
| "x-error-message": JSON.stringify(err_d.message), |
| "x-error-status": err_d.status |
| } |
| }); |
| }) |
|
|
| .use(CheckRouter) |
| .use(dlV1Router) |
| .use(FfmpegV2Router) |
| .use(BucketRouter) |
| .use(StreamRouter) |
| .use(proximaRouter) |
| .group("/dbproxy", (app) => app.use(ProxyDBRouter)) |
| .group("/dbfilm", (app) => app.use(filmDBRouter)) |
| .group("/dbbucket", (app) => app.use(bucketDBRouter)) |
| .group("/u", (app) => app.use(UserDBRouter)) |
|
|
| .mount("/", ProximaRouter.fetch) |
|
|
| .get("/", async ({ request }) => { |
| return "🦊 Hello Rafiki 🍿"; |
| }) |
|
|
| .get("/road", async () => { |
| return "11"; |
| }) |
|
|
| .ws("/ws", { |
| open(socket: any) { |
| const socket_id = socket.id; |
| const remote_address = socket.remoteAddress; |
|
|
| |
| NS_websockets.ws_clients.set(socket_id, { |
| socket, |
| channels: new Set<string>() |
| }); |
|
|
| if (!NS_runtime.IS_PROD()) { |
| console.log("WS CONNECTED:", remote_address, socket_id); |
| } |
|
|
| NS_websockets.ws_send({ |
| socket, |
| payload: { |
| type: "CONNECTED", |
| ws_id: socket_id |
| } |
| }); |
| }, |
|
|
| close(socket: any) { |
| const socket_id = socket.id; |
| const remote_address = socket.remoteAddress; |
|
|
| |
| const client = NS_websockets.ws_clients.get(socket_id); |
|
|
| if (client?.socket === socket) { |
| NS_websockets.ws_clients.delete(socket_id); |
| } |
|
|
| NS_server_stats.sync(); |
|
|
| if (!NS_runtime.IS_PROD()) { |
| console.log("WS CLOSED:", remote_address, socket_id); |
| } |
| }, |
|
|
| message(socket: any, message: any) { |
| const socket_id = socket.id; |
|
|
| let data: any; |
|
|
| try { |
| data = typeof message === "string" ? JSON.parse(message) : message; |
| } catch { |
| NS_websockets.ws_error({ socket, socket_id, message: "INVALID_JSON" }); |
| return; |
| } |
|
|
| if (!data || typeof data !== "object" || Array.isArray(data)) { |
| NS_websockets.ws_error({ |
| socket, |
| socket_id, |
| message: "INVALID_MESSAGE" |
| }); |
| return; |
| } |
|
|
| const client = NS_websockets.ws_clients.get(socket_id); |
|
|
| if (!client) { |
| NS_websockets.ws_error({ |
| socket, |
| socket_id, |
| message: "CLIENT_UNAVAILABLE" |
| }); |
| return; |
| } |
|
|
| |
| if (typeof data.channel?.connect === "string") { |
| const channel = data.channel.connect.trim(); |
|
|
| if (!channel) { |
| NS_websockets.ws_error({ |
| socket, |
| socket_id, |
| message: "INVALID_CHANNEL" |
| }); |
| return; |
| } |
|
|
| const already_connected = client.channels.has(channel); |
|
|
| client.channels.add(channel); |
|
|
| if (channel === "server-stats") { |
| NS_server_stats.sync(); |
|
|
| |
| socket.send( |
| JSON.stringify({ |
| type: "SERVER-STATS", |
| data: NS_server_stats.get() |
| }) |
| ); |
| } |
|
|
| NS_websockets.ws_send({ |
| socket, |
| payload: { |
| type: "CHANNEL-CONNECTED", |
| ws_id: socket_id, |
| channel, |
| already_connected, |
| channels: [...client.channels] |
| } |
| }); |
|
|
| return; |
| } |
|
|
| |
| if (typeof data.channel?.disconnect === "string") { |
| const channel = data.channel.disconnect.trim(); |
|
|
| if (!channel) { |
| NS_websockets.ws_error({ |
| socket, |
| socket_id, |
| message: "INVALID_CHANNEL" |
| }); |
| return; |
| } |
|
|
| const disconnected = client.channels.delete(channel); |
|
|
| if (channel === "server-stats") { |
| NS_server_stats.sync(); |
| } |
|
|
| NS_websockets.ws_send({ |
| socket, |
| payload: { |
| type: "CHANNEL-DISCONNECTED", |
| ws_id: socket_id, |
| channel, |
| disconnected, |
| channels: [...client.channels] |
| } |
| }); |
|
|
| return; |
| } |
|
|
| NS_websockets.ws_error({ socket, socket_id, message: "UNKNOWN_ACTION" }); |
| } |
| }) |
|
|
| .listen({ |
| port: PORT, |
| idleTimeout: 180 |
| }); |
|
|
| console.log( |
| `🦊 Elysia is running at ${app.server?.hostname}:${app.server?.port}` |
| ); |
|
|
