@long2ice/relayx-backend 0.0.1

package/dist/schemas/socket.io.d.ts

@@ -0,0 +1,33 @@
+import { Status } from "@/generated/prisma/client";
+export interface Sysinfo {
+    node_id: number;
+    status: Status;
+    version: string;
+    cpu_usage_percent: number;
+    net_in: number;
+    net_out: number;
+    arch: string;
+    boot_time: number;
+    cpu_num: number;
+    hostname: string;
+    load_1: number;
+    load_15: number;
+    load_5: number;
+    memory_total: number;
+    memory_usage_percent: number;
+    memory_used: number;
+    program_memory: number;
+    os: string;
+    process_num: number;
+    uptime: number;
+    disk_total: number;
+    disk_usage_percent: number;
+    disk_used: number;
+    traffic_in: number;
+    traffic_out: number;
+    tcp_connections: number;
+    udp_connections: number;
+    last_active: string;
+    traffic_month_in: number;
+    traffic_month_out: number;
+}

package/dist/schemas/tunnel.d.ts

@@ -0,0 +1,10 @@
+export type TunnelTraffic = {
+    tunnel_id: number;
+    traffic: number;
+    traffic_cost: number;
+};
+export type ListenProtocol = {
+    type: string;
+    username: string;
+    password: string;
+};

package/dist/services/dns/cloudflare.d.ts

@@ -0,0 +1,12 @@
+import { DNSProvider, RecordType, TTL } from "../../services/dns/interface";
+export default class CloudflareDNSProvider implements DNSProvider {
+    private readonly cloudflare;
+    private readonly domain;
+    private readonly rootDomain;
+    constructor(domain: string, config: Record<string, string>);
+    private getZoneId;
+    createRecord(ip: string, type: RecordType, ttl: TTL, weight: number, _line?: string): Promise<void>;
+    deleteRecord(ip: string): Promise<void>;
+    private getRecordId;
+    deleteRecords(): Promise<void>;
+}

package/dist/services/dns/huawei.d.ts

@@ -0,0 +1,12 @@
+import { DNSProvider, RecordType, TTL } from "../../services/dns/interface";
+export default class HuaweiDNSProvider implements DNSProvider {
+    private readonly domain;
+    private readonly client;
+    private readonly rootDomain;
+    constructor(domain: string, config: Record<string, string>);
+    private getZoneId;
+    createRecord(ip: string, type: RecordType, ttl: TTL, weight: number, line?: string): Promise<void>;
+    private getRecordsetId;
+    deleteRecord(ip: string): Promise<void>;
+    deleteRecords(): Promise<void>;
+}

package/dist/services/dns/index.d.ts

@@ -0,0 +1,4 @@
+import { DNSProviderType } from "@/generated/prisma/client";
+import CloudflareDNSProvider from "../../services/dns/cloudflare";
+import HuaweiDNSProvider from "../../services/dns/huawei";
+export declare const getDNSProvider: (type: DNSProviderType, domain: string, config: Record<string, string>) => CloudflareDNSProvider | HuaweiDNSProvider;

package/dist/services/dns/interface.d.ts

@@ -0,0 +1,8 @@
+export type RecordType = "A" | "AAAA";
+export type TTL = number | "auto";
+export interface DNSProvider {
+    createRecord(ip: string, type: RecordType, ttl: TTL, weight: number, line?: string): Promise<void>;
+    deleteRecord(ip: string): Promise<void>;
+    deleteRecords(): Promise<void>;
+}
+export declare function getRootDomain(domain: string): string;

package/dist/services/dns_provider.d.ts

@@ -0,0 +1,46 @@
+import { Prisma } from "@/generated/prisma/client";
+import { DNSProviderQuerySchema, DNSProviderRequestSchema } from "../schemas/request";
+import { z } from "zod";
+export declare class DNSProviderService {
+    createDNSProvider(data: z.infer<typeof DNSProviderRequestSchema>): Promise<{
+        name: string;
+        id: number;
+        created_at: Date;
+        updated_at: Date;
+        type: import("../generated/prisma/client").$Enums.DNSProviderType;
+        config: Prisma.JsonValue;
+    }>;
+    getDNSProviders(query: z.infer<typeof DNSProviderQuerySchema>): Promise<{
+        data: {
+            name: string;
+            id: number;
+            created_at: Date;
+            updated_at: Date;
+            type: import("../generated/prisma/client").$Enums.DNSProviderType;
+            config: Prisma.JsonValue;
+        }[];
+        total: number;
+    }>;
+    getDNSProviderById(id: number): Promise<{
+        name: string;
+        id: number;
+        created_at: Date;
+        updated_at: Date;
+        type: import("../generated/prisma/client").$Enums.DNSProviderType;
+        config: Prisma.JsonValue;
+    } | null>;
+    updateDNSProvider(id: number, data: z.infer<typeof DNSProviderRequestSchema>): Promise<{
+        name: string;
+        id: number;
+        created_at: Date;
+        updated_at: Date;
+        type: import("../generated/prisma/client").$Enums.DNSProviderType;
+        config: Prisma.JsonValue;
+    }>;
+    deleteDNSProviders(ids: number[]): Promise<void>;
+    getDNSProviderSummary(): Promise<{
+        name: string;
+        id: number;
+        type: import("../generated/prisma/client").$Enums.DNSProviderType;
+    }[]>;
+}

package/dist/services/email.d.ts

@@ -0,0 +1,11 @@
+import { SystemConfigService } from "../services/system_config";
+export declare class EmailService {
+    private readonly systemConfigService;
+    private transporterCache?;
+    constructor(systemConfigService: SystemConfigService);
+    private getEmailConfig;
+    private getSmtpTransporter;
+    private isSmtpEnabled;
+    private isResendEnabled;
+    sendEmail(to: string, subject: string, text: string, html?: string): Promise<boolean>;
+}

package/dist/services/fernet.d.ts

@@ -0,0 +1,2 @@
+import { fernet } from "@relayx/shared";
+export declare const fernetService: fernet.FernetService;

package/dist/services/in_node_group_dns.d.ts

@@ -0,0 +1,65 @@
+import type { z } from "zod";
+import { type NodeGroup } from "@/generated/prisma/client";
+import type { InNodeGroupDNSQuerySchema, InNodeGroupDNSRequestSchema } from "../schemas/request";
+import { RedisService } from "../services/redis";
+export declare class InNodeGroupDNSService {
+    private readonly redisService;
+    constructor(redisService: RedisService);
+    createInNodeGroupDNS(user_id: number, data: z.infer<typeof InNodeGroupDNSRequestSchema>): Promise<{
+        id: number;
+        created_at: Date;
+        updated_at: Date;
+        status: import("../generated/prisma/client").$Enums.Status;
+        in_node_group_id: number;
+        ipv6: boolean;
+        dns_provider_id: number;
+        ttl: number;
+    }>;
+    getInNodeGroupDNSList(user_id: number, query: z.infer<typeof InNodeGroupDNSQuerySchema>): Promise<{
+        data: ({
+            in_node_group: {
+                name: string;
+                id: number;
+                connect_ip: string | null;
+                nodes: {
+                    id: number;
+                    node_id: string;
+                    custom_line: string | null;
+                    dns_status: boolean;
+                }[];
+            };
+            dns_provider: {
+                name: string;
+                id: number;
+                type: import("../generated/prisma/client").$Enums.DNSProviderType;
+            };
+        } & {
+            id: number;
+            created_at: Date;
+            updated_at: Date;
+            status: import("../generated/prisma/client").$Enums.Status;
+            in_node_group_id: number;
+            ipv6: boolean;
+            dns_provider_id: number;
+            ttl: number;
+        })[];
+        total: number;
+    }>;
+    updateInNodeGroupDNS(user_id: number, id: number, data: z.infer<typeof InNodeGroupDNSRequestSchema>): Promise<{
+        id: number;
+        created_at: Date;
+        updated_at: Date;
+        status: import("../generated/prisma/client").$Enums.Status;
+        in_node_group_id: number;
+        ipv6: boolean;
+        dns_provider_id: number;
+        ttl: number;
+    }>;
+    private syncNodeCustomLines;
+    deleteInNodeGroupDNS(user_id: number, ids: number[]): Promise<void>;
+    nodeDnsRecords(in_node_group: NodeGroup, ips: string[], type: "create" | "delete", weight: number, nodeId?: number, customLine?: string | null): Promise<void>;
+    syncDNSRecords(user_id: number, id: number): Promise<{
+        synced: number;
+    }>;
+    cronSyncNodeDNS(): Promise<void>;
+}

package/dist/services/license.d.ts

@@ -0,0 +1,87 @@
+export declare enum LicenseType {
+    Personal = "personal",
+    Business = "business"
+}
+export declare enum CouponValidCycle {
+    Month = "month",
+    Year = "year",
+    Lifetime = "lifetime"
+}
+export declare class LicenseService {
+    payLicense(payment_id: number, pay_type: string | null, cycle: CouponValidCycle, redirect_url: string, client_ip: string, type: LicenseType, coupon?: string): Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+        200: {
+            pay_url: string;
+        };
+        400: {
+            readonly error: "商业授权无法降级为个人授权";
+        } | {
+            readonly error: "无效的周期";
+        } | {
+            readonly error: "无效的支付方式";
+        };
+        201: {
+            readonly pay_url: "";
+        };
+        422: {
+            type: "validation";
+            on: string;
+            summary?: string;
+            message?: string;
+            found?: unknown;
+            property?: string;
+            expected?: string;
+        };
+    }>>;
+    getLicenseFromServer(): Promise<{
+        expired_at: Date;
+        created_at: Date;
+        site_url: string;
+        type: "personal" | "business";
+        content: string;
+    } | null>;
+    getPay(): Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+        200: {
+            payments: {
+                id: number;
+                method: string;
+                name: string;
+                percent_fee: number;
+                type: string | null;
+            }[];
+            price: {
+                personal: {
+                    month: number;
+                    lifetime: number;
+                    enable_year: boolean;
+                };
+                business: {
+                    month: number;
+                    lifetime: number;
+                    enable_year: boolean;
+                };
+            };
+        };
+    }>>;
+    getCoupon(coupon: string, type: LicenseType, cycle: CouponValidCycle): Promise<{
+        type: string;
+        value: number;
+        validType: string;
+        validCycle: string;
+    } | null>;
+    getLicense(force?: boolean): Promise<import("../schemas/license").License | null>;
+    updateLicense(new_site_url: string): Promise<void>;
+    getHistory(): Promise<{
+        id: number;
+        price: number;
+        status: "pending" | "success" | "cancelled";
+        type: "personal" | "business";
+        expired_at: Date;
+        created_at: Date;
+        order_id: string;
+        coupon: {
+            code: string;
+            type: "percentage" | "fixed";
+            value: number;
+        } | null;
+    }[] | null>;
+}

package/dist/services/logger.d.ts

@@ -0,0 +1,7 @@
+declare const logger: import("pino").Logger<never, boolean>;
+export declare const requestLogger: import("hono").MiddlewareHandler<{
+    Variables: {
+        logger: import("hono-pino").PinoLogger;
+    };
+}>;
+export default logger;

package/dist/services/node.d.ts

@@ -0,0 +1,39 @@
+import type { z } from "zod";
+import type { NodeQuerySchema } from "../schemas/request";
+import { InNodeGroupDNSService } from "../services/in_node_group_dns";
+import { RedisService } from "../services/redis";
+export declare class NodeService {
+    private readonly redisService;
+    private readonly inNodeGroupDNSService;
+    constructor(redisService: RedisService, inNodeGroupDNSService: InNodeGroupDNSService);
+    checkNodeId(node_id: string): Promise<void>;
+    nodeIsAlive(node_group_id: number, node_id: number): Promise<boolean>;
+    deleteNodes(ids: number[], user_id?: number): Promise<void>;
+    getNodes(query: z.infer<typeof NodeQuerySchema>, user_id?: number): Promise<{
+        data: {
+            upgradeable: boolean;
+            last_active: any;
+            node_group: {
+                name: string;
+                node_type: import("../generated/prisma/client").$Enums.NodeType;
+                traffic_rate: number;
+            };
+            id: number;
+            connect_ip: string;
+            order_by: number;
+            created_at: Date;
+            updated_at: Date;
+            status: import("../generated/prisma/client").$Enums.Status;
+            weight: number;
+            node_id: string;
+            version: string;
+            backup: boolean;
+            custom_line: string | null;
+            dns_status: boolean;
+            node_group_id: number;
+        }[];
+        total: number;
+    }>;
+    updateNodeOrder(id: number, order_by: number, user_id?: number): Promise<void>;
+    upgradeAllNodes(user_id?: number): Promise<void>;
+}

package/dist/services/node_group.d.ts

@@ -0,0 +1,75 @@
+import { Prisma, User } from "@/generated/prisma/client";
+import { NodeGroupQuerySchema, NodeGroupRequestSchema } from "../schemas/request";
+import { RedisService } from "../services/redis";
+import { z } from "zod";
+export declare class NodeGroupService {
+    private readonly redisService;
+    constructor(redisService: RedisService);
+    checkUserNodeGroup(user: User, in_node_group_id: number, out_node_group_id: number | null): Promise<void>;
+    getUserNodeGroups(user: User): Promise<{
+        node_count: number | undefined;
+        name: string;
+        id: number;
+        node_type: import("../generated/prisma/client").$Enums.NodeType;
+        allow_listen_protocol: boolean;
+        allow_tunnel_types: Prisma.JsonValue;
+        admission: boolean;
+        block_protocols: Prisma.JsonValue;
+        traffic_rate: number;
+        need_out_node_group: boolean;
+        allow_out_node_groups: Prisma.JsonValue;
+        allow_in_node_groups: Prisma.JsonValue;
+        user_id: number;
+    }[]>;
+    getAdminNodeGroupSummary(): Promise<{
+        name: string;
+        id: number;
+        node_type: import("../generated/prisma/client").$Enums.NodeType;
+        allow_listen_protocol: boolean;
+        allow_tunnel_types: Prisma.JsonValue;
+        admission: boolean;
+        block_protocols: Prisma.JsonValue;
+        traffic_rate: number;
+        need_out_node_group: boolean;
+        allow_out_node_groups: Prisma.JsonValue;
+        allow_in_node_groups: Prisma.JsonValue;
+    }[]>;
+    createNodeGroup(user_id: number, data: z.infer<typeof NodeGroupRequestSchema>): Promise<void>;
+    getNodeGroups(query: z.infer<typeof NodeGroupQuerySchema>, user_id?: number): Promise<{
+        data: ({
+            user: {
+                email: string;
+            };
+            nodes: {
+                connect_ip: string;
+            }[];
+        } & {
+            name: string;
+            id: number;
+            token: string;
+            port_range: string | null;
+            connect_ip: string | null;
+            node_type: import("../generated/prisma/client").$Enums.NodeType;
+            load_balance_type: import("../generated/prisma/client").$Enums.LoadBalanceType;
+            allow_listen_protocol: boolean;
+            allow_tunnel_types: Prisma.JsonValue | null;
+            bypass_type: import("../generated/prisma/client").$Enums.BypassType;
+            bypass_list: Prisma.JsonValue | null;
+            admission: boolean;
+            block_protocols: Prisma.JsonValue | null;
+            traffic_rate: number;
+            need_out_node_group: boolean;
+            allow_out_node_groups: Prisma.JsonValue | null;
+            allow_in_node_groups: Prisma.JsonValue | null;
+            order_by: number;
+            created_at: Date;
+            updated_at: Date;
+            user_id: number;
+        })[];
+        total: number;
+    }>;
+    deleteNodeGroups(ids: number[], user_id?: number): Promise<void>;
+    updateNodeGroup(id: number, data: z.infer<typeof NodeGroupRequestSchema>, user_id?: number): Promise<void>;
+    updateNodeGroupOrder(id: number, order_by: number, user_id?: number): Promise<void>;
+    checkPortRange(port_range: string | null, port?: number): boolean | undefined;
+}

package/dist/services/notify.d.ts

@@ -0,0 +1,44 @@
+import { Plan, Ticket, TopupOrder, User } from "@/generated/prisma/client";
+import { EmailService } from "../services/email";
+import { TelegramService } from "../services/telegram";
+import { UserService } from "../services/user";
+export declare enum NotifyType {
+    topup = "topup",
+    subscribe_plan = "subscribe_plan",
+    node_register = "node_register",
+    renew_plan_failed = "renew_plan_failed",
+    node_disconnect = "node_disconnect",
+    plan_expire = "plan_expire",
+    ticket_created = "ticket_created",
+    ticket_replied = "ticket_replied"
+}
+export declare class NotifyService {
+    private readonly telegramService;
+    private readonly userService;
+    private readonly emailService;
+    constructor(telegramService: TelegramService, userService: UserService, emailService: EmailService);
+    private formatTopupMessage;
+    private formatUserTopupMessage;
+    private formatSubscribePlanMessage;
+    private formatRegisterMessage;
+    private formatRenewPlanFailedMessage;
+    private formatNodeDisconnectMessage;
+    private formatPlanExpireMessage;
+    private escapeHtml;
+    private renderEmailTemplate;
+    private createTopupEmail;
+    private createAdminTopupEmail;
+    private createSubscribePlanEmail;
+    private createNodeRegisterEmail;
+    private createRenewPlanFailedEmail;
+    private createNodeDisconnectEmail;
+    private createPlanExpireEmail;
+    notifyTopup(order: TopupOrder): Promise<void>;
+    notifySubscribePlan(user: User, plan: Plan, price: number, balance: number): Promise<void>;
+    notifyNodeRegister(node_id: string, group_name: string, user: User): Promise<void>;
+    notifyRenewPlanFailed(user: User, plan_name: string, reason: string, expire_at: Date): Promise<void>;
+    notifyNodeDisconnect(node_id: string, group_name: string, user: User, last_active: Date): Promise<void>;
+    notifyPlanExpire(user: User, plan_name: string, expire_at: Date): Promise<void>;
+    notifyTicketCreated(ticket: Ticket, user: User): Promise<void>;
+    notifyTicketReplied(ticket: Ticket, replierEmail: string, isAdmin: boolean): Promise<void>;
+}

package/dist/services/order.d.ts

@@ -0,0 +1,3 @@
+export declare class OrderService {
+    cancelUnpaidOrder(id: number): Promise<void>;
+}

package/dist/services/pay.d.ts

@@ -0,0 +1,6 @@
+import { Payment } from "@/generated/prisma/client";
+import { pay } from "@relayx/shared";
+export declare const getPayment: (payment: Payment) => pay.EPay | pay.BEPUSDT | pay.Heleket;
+export declare class PaymentService {
+    updatePayOrder(id: number, order_by: number): Promise<void>;
+}

package/dist/services/plan.d.ts

@@ -0,0 +1,119 @@
+import { User } from "@/generated/prisma/client";
+import { PlanCouponService } from "../services/plan_coupon";
+import { NotifyService } from "../services/notify";
+import { RedisService } from "../services/redis";
+import { SystemConfigService } from "../services/system_config";
+import { TopupService } from "../services/topup";
+import { SortingState } from "@tanstack/react-table";
+export declare class PlanService {
+    private readonly planCouponService;
+    private readonly redisService;
+    private readonly notifyService;
+    private readonly systemConfigService;
+    private readonly topupService;
+    constructor(planCouponService: PlanCouponService, redisService: RedisService, notifyService: NotifyService, systemConfigService: SystemConfigService, topupService: TopupService);
+    deletePlans(ids: number[]): Promise<void>;
+    getUserPlan(user: User): Promise<({
+        plan: {
+            name: string;
+            id: number;
+            order_by: number;
+            created_at: Date;
+            updated_at: Date;
+            status: import("../generated/prisma/client").$Enums.Status;
+            ip_limit: number | null;
+            bandwidth_limit: number | null;
+            traffic: number | null;
+            price: number;
+            max_tunnels: number | null;
+            description: string | null;
+            original_price: number | null;
+            allow_custom_in_node_group: boolean;
+            allow_custom_out_node_group: boolean;
+            all_in_node_groups: boolean;
+            all_out_node_groups: boolean;
+            setup_fee: number | null;
+            billing_cycle: import("../generated/prisma/client").$Enums.BillingCycle;
+            renewable: boolean;
+            stock: number | null;
+        };
+    } & {
+        id: number;
+        created_at: Date;
+        updated_at: Date;
+        user_id: number;
+        traffic: number | null;
+        plan_id: number;
+        traffic_used: number;
+        max_tunnels: number | null;
+        expired_at: Date | null;
+    }) | null>;
+    checkUserPlan(user: User): Promise<{
+        plan: {
+            name: string;
+            id: number;
+            order_by: number;
+            created_at: Date;
+            updated_at: Date;
+            status: import("../generated/prisma/client").$Enums.Status;
+            ip_limit: number | null;
+            bandwidth_limit: number | null;
+            traffic: number | null;
+            price: number;
+            max_tunnels: number | null;
+            description: string | null;
+            original_price: number | null;
+            allow_custom_in_node_group: boolean;
+            allow_custom_out_node_group: boolean;
+            all_in_node_groups: boolean;
+            all_out_node_groups: boolean;
+            setup_fee: number | null;
+            billing_cycle: import("../generated/prisma/client").$Enums.BillingCycle;
+            renewable: boolean;
+            stock: number | null;
+        };
+    } & {
+        id: number;
+        created_at: Date;
+        updated_at: Date;
+        user_id: number;
+        traffic: number | null;
+        plan_id: number;
+        traffic_used: number;
+        max_tunnels: number | null;
+        expired_at: Date | null;
+    }>;
+    renewUsersPlan(): Promise<void>;
+    renewUserPlan(user: User): Promise<void>;
+    subscribePlan(user: User, plan_id: number, auto_renew?: boolean, code?: string, remaining_traffic?: number): Promise<void>;
+    getPlanOrders(page: number, perPage: number, user_id?: number, sort?: SortingState | null, plan_id?: number, email?: string): Promise<{
+        data: ({
+            user: {
+                email: string;
+            };
+            plan: {
+                name: string;
+                price: number;
+            };
+            coupon: {
+                type: import("../generated/prisma/client").$Enums.CouponType;
+                value: number;
+            } | null;
+        } & {
+            id: number;
+            created_at: Date;
+            updated_at: Date;
+            user_id: number;
+            balance: number;
+            plan_id: number;
+            price: number;
+            coupon_id: number | null;
+        })[];
+        total: number;
+    }>;
+    updatePlanOrder(id: number, order_by: number): Promise<void>;
+    getPlanSummary(): Promise<{
+        name: string;
+        id: number;
+    }[]>;
+}

package/dist/services/plan_coupon.d.ts

@@ -0,0 +1,16 @@
+import { BillingCycle } from "@/generated/prisma/client";
+export declare class PlanCouponService {
+    getCoupon(code: string, cycle: BillingCycle, user_id: number): Promise<{
+        id: number;
+        created_at: Date;
+        updated_at: Date;
+        type: import("../generated/prisma/client").$Enums.CouponType;
+        value: number;
+        code: string;
+        valid_start: Date | null;
+        valid_end: Date | null;
+        valid_cycle: import("../generated/prisma/client").$Enums.BillingCycle | null;
+        max_use: number | null;
+        max_use_per_user: number | null;
+    }>;
+}