| import { type Context, Elysia, t } from "elysia"; |
| import { NS_runtime, IS_HF } from "@x/types/env.runtime"; |
| import { offline_store } from "@x/ff-dl/offline-store"; |
| import { NS_promise } from "@x/core/client/promise.ts"; |
| import { NS_error } from "@x/core/client/error.ts"; |
| import { NS_ff_dl_stream } from "@x/ff-dl/dl-stream"; |
| import { NS_Misc } from "@x/core/client/misc.ts"; |
| import { redis } from "@x/post-process/cache"; |
| import { NS_crypto_client } from "@x/core/client/crypto.ts"; |
|
|
| const APP_ACCOUNT_ABC = () => |
| NS_runtime.ENV_VAR_DB?.APP_ACCOUNT_ABC || process.env.APP_ACCOUNT_ABC; |
|
|
| const APP_ENV = () => NS_runtime.ENV_VAR_DB?.APP_ENV || process.env.APP_ENV; |
|
|
| const REPO_ORIGIN = () => |
| NS_runtime.ENV_VAR_DB?.REPO_ORIGIN || process.env.REPO_ORIGIN; |
|
|
| const APP_ORIGIN = () => |
| NS_runtime.ENV_VAR_DB?.APP_ORIGIN || process?.env?.APP_ORIGIN; |
|
|
| const HF_BUCKET_NAME = () => |
| NS_runtime.ENV_VAR_DB?.HF_BUCKET_NAME || process.env.HF_BUCKET_NAME; |
|
|
| const is_dev = (() => { |
| |
| return APP_ENV() === "dev"; |
| })(); |
|
|
| const sub_router = new Elysia({ prefix: "/stream" }).get( |
| "/delivery/:data_key", |
| async (ctx) => { |
| const { params, query, request } = ctx; |
| let { data_key } = params; |
| let { ops } = query; |
|
|
| const REQ0 = new URL(request.url); |
| const REQ_ORIGIN = (ctx as any).publicOrigin || REQ0.origin; |
|
|
| const metadata = await (async () => { |
| try { |
| const [E_, R_] = await NS_promise.F_catch_promise({ |
| promise: (async () => { |
| return NS_crypto_client.F_decode_unicode_v1({ |
| data_str: data_key, |
| _is_url_safe: true, |
| encoded: "hex" |
| }); |
| })() |
| }); |
|
|
| if (NS_Misc.F_is_record(R_)) return R_; |
|
|
| if (APP_ENV() === "dev") { |
| const _ = offline_store.get(data_key); |
|
|
| if (_) return _; |
| } |
|
|
| const _ = await redis()?.get(data_key); |
|
|
| return _; |
| } catch { |
| return; |
| } |
| })(); |
|
|
| if (!metadata) { |
| return ctx.status(404, "Metadata not found"); |
| } |
|
|
| if (ops === "raw" || ops === "decode") { |
| return metadata; |
| } |
|
|
| const req_signal = ctx?.request.signal; |
|
|
| const [E_, R_] = await NS_promise.F_catch_promise({ |
| promise: NS_ff_dl_stream.handle_payload({ |
| data_key, |
| metadata, |
| REQ0, |
| REQ_ORIGIN, |
| req_signal, |
| ops |
| }) |
| }); |
|
|
| if (E_) { |
| const { message, status } = NS_error.F_collect_error_status_n_message({ |
| ERR: E_ |
| }); |
|
|
| return ctx.status(status, message); |
| } |
|
|
| if (typeof R_ === "object" && NS_Misc.F_is_record(R_)) { |
| const _redirect = (R_ as any).redirect; |
|
|
| if (_redirect) return ctx.redirect(_redirect, 302); |
| } |
|
|
| return R_; |
| }, |
| { |
| params: t.Object({ |
| data_key: t.String({ |
| minLength: 1, |
| error() { |
| return "Invalid process data, Expected string"; |
| } |
| }) |
| }), |
| query: t.Object({ |
| raw: t.Optional( |
| t.Number({ |
| minimum: 0, |
| maximum: 1, |
| error: () => "Invalid raw, Expected binary boolean" |
| }) |
| ), |
| ops: t.Optional( |
| t.Union( |
| [ |
| t.Literal("cmd"), |
| t.Literal("raw"), |
| t.Literal("decode"), |
| t.Literal("jc") |
| ], |
| { |
| error() { |
| return "Invalid operation, must be one of: cmd, raw, decode"; |
| } |
| } |
| ) |
| ) |
| }) |
| } |
| ); |
|
|
| export const StreamRouter = sub_router; |
| export const StreamRouterHandlePayload = NS_ff_dl_stream.handle_payload; |
|
|
