@remnawave/backend-contract 0.0.1

package/build/models/nodes.schema.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodesSchema = void 0;
+const zod_1 = require("zod");
+exports.NodesSchema = zod_1.z.object({
+    uuid: zod_1.z.string().uuid(),
+    name: zod_1.z.string(),
+    address: zod_1.z.string(),
+    port: zod_1.z.number().int().nullable(),
+    isConnected: zod_1.z.boolean().default(false),
+    isDisabled: zod_1.z.boolean().default(false),
+    isConnecting: zod_1.z.boolean().default(false),
+    isNodeOnline: zod_1.z.boolean().default(false),
+    isXrayRunning: zod_1.z.boolean().default(false),
+    lastStatusChange: zod_1.z.date().nullable(),
+    lastStatusMessage: zod_1.z.string().nullable(),
+    xrayVersion: zod_1.z.string().nullable(),
+    isTrafficTrackingActive: zod_1.z.boolean().default(false),
+    trafficResetDay: zod_1.z.number().int().nullable(),
+    trafficLimitBytes: zod_1.z.number().nullable(),
+    trafficUsedBytes: zod_1.z.number().nullable(),
+    notifyPercent: zod_1.z.number().int().nullable(),
+    cpuCount: zod_1.z.number().int().nullable(),
+    cpuModel: zod_1.z.string().nullable(),
+    totalRam: zod_1.z.string().nullable(),
+    createdAt: zod_1.z.date(),
+    updatedAt: zod_1.z.date(),
+});

package/build/models/users.schema.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UsersSchema = void 0;
+const zod_1 = require("zod");
+const constants_1 = require("../constants");
+const inbounds_schema_1 = require("./inbounds.schema");
+exports.UsersSchema = zod_1.z.object({
+    uuid: zod_1.z.string().uuid(),
+    subscriptionUuid: zod_1.z.string().uuid(),
+    shortUuid: zod_1.z.string(),
+    username: zod_1.z.string(),
+    status: zod_1.z
+        .enum([constants_1.USERS_STATUS_VALUES[0], ...constants_1.USERS_STATUS_VALUES])
+        .default(constants_1.USERS_STATUS_VALUES[0]),
+    usedTrafficBytes: zod_1.z.number().int().default(0),
+    trafficLimitBytes: zod_1.z.number().int().default(0),
+    trafficLimitStrategy: zod_1.z
+        .enum([constants_1.RESET_PERIODS_VALUES[0], ...constants_1.RESET_PERIODS_VALUES], {
+        description: 'Available reset periods',
+    })
+        .default(constants_1.RESET_PERIODS_VALUES[0]),
+    subLastUserAgent: zod_1.z.nullable(zod_1.z.string()),
+    subLastOpenedAt: zod_1.z.nullable(zod_1.z.date()),
+    expireAt: zod_1.z.date(),
+    onlineAt: zod_1.z.date().nullable(),
+    subRevokedAt: zod_1.z.date().nullable(),
+    lastTrafficResetAt: zod_1.z.date().nullable(),
+    trojanPassword: zod_1.z.string(),
+    vlessUuid: zod_1.z.string().uuid(),
+    ssPassword: zod_1.z.string(),
+    createdAt: zod_1.z.date(),
+    updatedAt: zod_1.z.date(),
+    activeUserInbounds: zod_1.z.array(inbounds_schema_1.InboundsSchema),
+});

package/commands/api-tokens/create.command.ts

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import { REST_API } from '../../api';
+
+export namespace CreateApiTokenCommand {
+    export const url = REST_API.API_TOKENS.CREATE;
+
+    export const RequestSchema = z.object({
+        tokenName: z.string(),
+        tokenDescription: z.string().nullable(),
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        response: z.object({
+            token: z.string(),
+            uuid: z.string(),
+        }),
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/api-tokens/delete.command.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { REST_API } from '../../api';
+
+export namespace DeleteApiTokenCommand {
+    export const url = REST_API.API_TOKENS.DELETE;
+
+    export const RequestSchema = z.object({
+        uuid: z.string().uuid(),
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        response: z.boolean(),
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/api-tokens/find.command.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import { REST_API } from '../../api';
+import { ApiTokensSchema } from '../../models/api-tokens.schema';
+
+export namespace FindAllApiTokensCommand {
+    export const url = REST_API.API_TOKENS.GET_ALL;
+
+    export const ResponseSchema = z.object({
+        response: z.array(ApiTokensSchema),
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/api-tokens/index.ts

@@ -0,0 +1,3 @@
+export * from './create.command';
+export * from './delete.command';
+export * from './find.command';

package/commands/auth/index.ts

@@ -0,0 +1 @@
+export * from './login.command';

package/commands/auth/login.command.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { REST_API } from '../../api';
+export namespace LoginCommand {
+    export const url = REST_API.AUTH.LOGIN;
+
+    export const RequestSchema = z.object({
+        username: z.string(),
+        password: z.string(),
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        response: z.object({
+            accessToken: z.string(),
+        }),
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/hosts/create.command.ts

@@ -0,0 +1,52 @@
+import { z } from 'zod';
+import { REST_API } from '../../api';
+import { ALPN } from '../../constants/hosts/alpn';
+import { FINGERPRINTS } from '../../constants/hosts/fingerprints';
+import { HostsSchema } from '../../models';
+
+export namespace CreateHostCommand {
+    export const url = REST_API.HOSTS.CREATE;
+
+    export const RequestSchema = HostsSchema.pick({}).extend({
+        inboundUuid: z
+            .string({
+                invalid_type_error: 'Inbound UUID must be a string',
+            })
+            .uuid('Inbound UUID must be a valid UUID'),
+        viewPosition: z
+            .number({
+                invalid_type_error: 'View position must be an integer',
+            })
+            .int()
+            .optional(),
+        remark: z
+            .string({
+                invalid_type_error: 'Remark must be a string',
+            })
+            .max(40, {
+                message: 'Remark must be less than 40 characters',
+            }),
+        address: z.string({
+            invalid_type_error: 'Address must be a string',
+        }),
+        port: z
+            .number({
+                invalid_type_error: 'Port must be an integer',
+            })
+            .int(),
+        path: z.string().optional(),
+        sni: z.string().optional(),
+        host: z.string().optional(),
+        alpn: z.nativeEnum(ALPN).optional(),
+        fingerprint: z.nativeEnum(FINGERPRINTS).optional(),
+        allowInsecure: z.boolean().optional().default(false),
+        isDisabled: z.boolean().optional().default(false),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        response: HostsSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/hosts/delete.command.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { REST_API } from '../../api';
+
+export namespace DeleteHostCommand {
+    export const url = REST_API.HOSTS.DELETE;
+
+    export const RequestSchema = z.object({
+        uuid: z.string().uuid(),
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        response: z.object({
+            isDeleted: z.boolean(),
+        }),
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/hosts/index.ts

@@ -0,0 +1,2 @@
+export * from './create.command';
+export * from './delete.command';

package/commands/inbounds/get-inbounds.command.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import { REST_API } from '../../api';
+import { InboundsSchema } from '../../models/inbounds.schema';
+
+export namespace GetInboundsCommand {
+    export const url = REST_API.INBOUNDS.GET_INBOUNDS;
+
+    export const ResponseSchema = z.object({
+        response: z.array(InboundsSchema.pick({ tag: true, uuid: true })),
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/inbounds/index.ts

@@ -0,0 +1 @@
+export * from './get-inbounds.command';

package/commands/index.ts

@@ -0,0 +1,9 @@
+export * from './api-tokens';
+export * from './auth';
+export * from './hosts';
+export * from './inbounds';
+export * from './keygen';
+export * from './nodes';
+export * from './subscription';
+export * from './users';
+export * from './xray';

package/commands/keygen/get-pubkey.command.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { REST_API } from '../../api';
+
+export namespace GetPubKeyCommand {
+    export const url = REST_API.KEYGEN.GET;
+
+    export const ResponseSchema = z.object({
+        response: z.object({
+            pubKey: z.string(),
+        }),
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/keygen/index.ts

@@ -0,0 +1 @@
+export * from './get-pubkey.command';

package/commands/nodes/create.command.ts

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+import { REST_API } from '../../api';
+import { NodesSchema } from '../../models';
+
+export namespace CreateNodeCommand {
+    export const url = REST_API.NODES.CREATE;
+
+    export const RequestSchema = NodesSchema.pick({}).extend({
+        name: z.string().min(5, 'Name is required'),
+        address: z.string().min(2, 'Address is required'),
+        port: z.number().int().min(1, 'Port is required').optional(),
+        isTrafficTrackingActive: z.boolean().optional().default(false),
+        trafficLimitBytes: z
+            .number()
+            .int()
+            .min(0, 'Traffic limit must be greater than 0')
+            .optional(),
+        notifyPercent: z
+            .number()
+            .int()
+            .min(0, 'Notify percent must be greater than 0')
+            .max(100, 'Notify percent must be less than 100')
+            .optional(),
+        trafficResetDay: z
+            .number()
+            .int()
+            .min(1, 'Traffic reset day must be greater than 0')
+            .max(31, 'Traffic reset day must be less than 31')
+            .optional(),
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        response: NodesSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/nodes/delete.command.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { REST_API } from '../../api';
+
+export namespace DeleteNodeCommand {
+    export const url = REST_API.NODES.DELETE;
+
+    export const RequestSchema = z.object({
+        uuid: z.string().uuid(),
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        response: z.object({
+            isDeleted: z.boolean(),
+        }),
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/nodes/disable.command.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import { REST_API } from '../../api';
+import { NodesSchema } from '../../models';
+
+export namespace DisableNodeCommand {
+    export const url = REST_API.NODES.DISABLE;
+
+    export const RequestSchema = z.object({
+        uuid: z.string().uuid(),
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        response: NodesSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/nodes/enable.command.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import { REST_API } from '../../api';
+import { NodesSchema } from '../../models';
+
+export namespace EnableNodeCommand {
+    export const url = REST_API.NODES.ENABLE;
+
+    export const RequestSchema = z.object({
+        uuid: z.string().uuid(),
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        response: NodesSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/nodes/get-all.command.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import { REST_API } from '../../api';
+import { NodesSchema } from '../../models';
+
+export namespace GetAllNodesCommand {
+    export const url = REST_API.NODES.GET_ALL;
+
+    export const ResponseSchema = z.object({
+        response: z.array(NodesSchema),
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/nodes/get-one.command.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import { REST_API } from '../../api';
+import { NodesSchema } from '../../models';
+
+export namespace GetOneNodeCommand {
+    export const url = REST_API.NODES.GET_ONE;
+
+    export const RequestSchema = z.object({
+        uuid: z.string().uuid(),
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        response: NodesSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/nodes/index.ts

@@ -0,0 +1,9 @@
+export * from './create.command';
+export * from './delete.command';
+export * from './disable.command';
+export * from './enable.command';
+export * from './get-all.command';
+export * from './get-one.command';
+export * from './restart-all.command';
+export * from './restart.command';
+export * from './update.command';

package/commands/nodes/restart-all.command.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import { REST_API } from '../../api';
+export namespace RestartAllNodesCommand {
+    export const url = REST_API.NODES.RESTART_ALL;
+
+    export const ResponseSchema = z.object({
+        response: z.object({
+            eventSent: z.boolean(),
+        }),
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/nodes/restart.command.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { REST_API } from '../../api';
+
+export namespace RestartNodeCommand {
+    export const url = REST_API.NODES.RESTART;
+
+    export const RequestSchema = z.object({
+        uuid: z.string().uuid(),
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        response: z.object({
+            eventSent: z.boolean(),
+        }),
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/nodes/update.command.ts

@@ -0,0 +1,41 @@
+import { z } from 'zod';
+import { REST_API } from '../../api';
+import { NodesSchema } from '../../models';
+
+export namespace UpdateNodeCommand {
+    export const url = REST_API.NODES.UPDATE;
+
+    export const RequestSchema = NodesSchema.pick({
+        uuid: true,
+    }).extend({
+        name: z.string().min(5, 'Name is required').optional(),
+        address: z.string().min(2, 'Address is required').optional(),
+        port: z.number().int().min(1, 'Port is required').optional(),
+        isTrafficTrackingActive: z.boolean().optional(),
+        trafficLimitBytes: z
+            .number()
+            .int()
+            .min(0, 'Traffic limit must be greater than 0')
+            .optional(),
+        notifyPercent: z
+            .number()
+            .int()
+            .min(0, 'Notify percent must be greater than 0')
+            .max(100, 'Notify percent must be less than 100')
+            .optional(),
+        trafficResetDay: z
+            .number()
+            .int()
+            .min(1, 'Traffic reset day must be greater than 0')
+            .max(31, 'Traffic reset day must be less than 31')
+            .optional(),
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        response: NodesSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/subscription/get-subscription-by-short-uuid.command.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import { REST_API } from '../../api';
+
+export namespace GetSubscriptionByShortUuidCommand {
+    export const url = REST_API.SUBSCRIPTION.GET;
+
+    export const RequestSchema = z.object({
+        shortUuid: z.string(),
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+}

package/commands/subscription/get-subscription-info-by-short-uuid.command.ts

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+import { REST_API } from '../../api';
+import { USERS_STATUS_VALUES } from '../../constants';
+
+export namespace GetSubscriptionInfoByShortUuidCommand {
+    export const url = REST_API.SUBSCRIPTION.GET_INFO;
+
+    export const RequestSchema = z.object({
+        shortUuid: z.string(),
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        response: z.object({
+            isFound: z.boolean(),
+            user: z.object({
+                shortUuid: z.string(),
+                daysLeft: z.number(),
+                trafficUsed: z.string(),
+                trafficLimit: z.string(),
+                username: z.string(),
+                expiresAt: z.date(),
+                isActive: z.boolean(),
+                userStatus: z.enum([USERS_STATUS_VALUES[0], ...USERS_STATUS_VALUES]),
+            }),
+        }),
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/subscription/index.ts

@@ -0,0 +1,2 @@
+export * from './get-subscription-by-short-uuid.command';
+export * from './get-subscription-info-by-short-uuid.command';

package/commands/users/create-user.command.ts

@@ -0,0 +1,103 @@
+import { z } from 'zod';
+import { REST_API } from '../../api';
+import { RESET_PERIODS, USERS_STATUS } from '../../constants';
+import { InboundsSchema, UsersSchema } from '../../models';
+
+export namespace CreateUserCommand {
+    export const url = REST_API.USERS.CREATE;
+
+    export const RequestSchema = UsersSchema.pick({}).extend({
+        username: z
+            .string({
+                required_error: 'Username is required',
+                invalid_type_error: 'Username must be a string',
+            })
+            .regex(
+                /^[a-zA-Z0-9_-]+$/,
+                'Username can only contain letters, numbers, underscores and dashes',
+            )
+            .max(32, 'Username must be less than 32 characters')
+            .min(6, 'Username must be at least 6 characters'),
+        status: UsersSchema.shape.status.optional().default(USERS_STATUS.ACTIVE),
+        subscriptionUuid: z
+            .string({
+                invalid_type_error: 'Subscription UUID must be a string',
+            })
+            .uuid('Invalid subscription UUID format')
+            .optional(),
+        shortUuid: z
+            .string({
+                invalid_type_error: 'Short UUID must be a string',
+            })
+            .optional(),
+        trojanPassword: z
+            .string({
+                invalid_type_error: 'Trojan password must be a string',
+            })
+            .min(8, 'Trojan password must be at least 8 characters')
+            .max(32, 'Trojan password must be less than 32 characters')
+            .optional(),
+        vlessUuid: z
+            .string({
+                invalid_type_error: 'Vless UUID must be a string',
+            })
+            .uuid('Invalid Vless UUID format')
+            .optional(),
+        ssPassword: z
+            .string({
+                invalid_type_error: 'SS password must be a string',
+            })
+            .min(8, 'SS password must be at least 8 characters')
+            .max(32, 'SS password must be less than 32 characters')
+            .optional(),
+        trafficLimitBytes: z
+            .number({
+                invalid_type_error: 'Traffic limit must be a number',
+            })
+            .int('Traffic limit must be an integer')
+            .min(0, 'Traffic limit must be greater than 0')
+            .describe('Traffic limit in bytes. 0 - unlimited')
+            .optional(),
+        trafficLimitStrategy: UsersSchema.shape.trafficLimitStrategy
+            .describe('Traffic limit reset strategy')
+            .optional()
+            .default(RESET_PERIODS.NO_RESET)
+            .superRefine((val, ctx) => {
+                if (val && !Object.values(RESET_PERIODS).includes(val)) {
+                    ctx.addIssue({
+                        code: z.ZodIssueCode.invalid_enum_value,
+                        message: 'Invalid traffic limit strategy',
+                        path: ['trafficLimitStrategy'],
+                        received: val,
+                        options: Object.values(RESET_PERIODS),
+                    });
+                }
+            }),
+        enabledInbounds: z
+            .array(
+                InboundsSchema.pick({
+                    uuid: true,
+                }),
+                {
+                    invalid_type_error: 'Enabled inbounds must be an array',
+                },
+            )
+            .optional(),
+        expireAt: z.coerce
+            .date({
+                required_error: 'Expiration date is required',
+                invalid_type_error: 'Invalid expiration date format',
+            })
+            .refine((date) => date > new Date(), {
+                message: 'Expiration date cannot be in the past',
+            }),
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        response: UsersSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}