refactor: improve type safety and error handling across modules

- Added `.local(true)` to datetime validation in user creation schema
- Updated Xray config schemas to use `.passthrough()` for flexible config handling
- Simplified error messages and removed unnecessary console logs
- Enhanced null safety in subscription and config generation modules
- Improved type handling in Xray config service and inbound synchronization

Author: kastov

libs/contract/commands/users/create-user.command.ts

@@ -92,15 +92,15 @@ export namespace CreateUserCommand {
             .string({
                 invalid_type_error: 'Invalid date format',
             })
-            .datetime({ message: 'Invalid date format', offset: true })
+            .datetime({ message: 'Invalid date format', offset: true, local: true })
             .transform((str) => new Date(str))
             .describe('Date format: 2025-01-17T15:38:45.065Z')
             .optional(),
         lastTrafficResetAt: z
             .string({
                 invalid_type_error: 'Invalid date format',
             })
-            .datetime({ message: 'Invalid date format', offset: true })
+            .datetime({ message: 'Invalid date format', offset: true, local: true })
             .transform((str) => new Date(str))
             .describe('Date format: 2025-01-17T15:38:45.065Z')
             .optional(),

libs/contract/commands/xray/get-config.command.ts

@@ -7,7 +7,7 @@ export namespace GetXrayConfigCommand {
 
     export const ResponseSchema = z.object({
         response: z.object({
-            config: z.object({}),
+            config: z.object({}).passthrough(),
         }),
     });
 

libs/contract/commands/xray/update-config.command.ts

@@ -6,13 +6,13 @@ export namespace UpdateXrayConfigCommand {
     export const url = REST_API.XRAY.UPDATE_CONFIG;
     export const TSQ_url = url;
 
-    export const RequestSchema = z.object({});
+    export const RequestSchema = z.object({}).passthrough();
 
     export type Request = z.infer<typeof RequestSchema>;
 
     export const ResponseSchema = z.object({
         response: z.object({
-            config: z.object({}),
+            config: z.object({}).passthrough(),
         }),
     });
 

libs/contract/constants/errors/errors.ts

@@ -302,7 +302,7 @@ export const ERRORS = {
         httpCode: 500,
         withMessage: (message: string) => ({
             code: 'A061',
-            message: message,
+            message,
             httpCode: 500,
         }),
     },

src/modules/subscription/generators/by-subcription-type/generate-singbox-config.ts

@@ -372,7 +372,7 @@ export class SingBoxConfiguration {
 
             this.add_outbound(outbound);
         } catch (error) {
-            console.log(error);
+            // silence error
         }
     }
 }

src/modules/subscription/generators/by-subcription-type/generate-xray-config.ts

@@ -112,9 +112,11 @@ export class XrayLinksGenerator {
         }
 
         if (params.network === 'ws') {
-            Object.assign(payload, {
-                heartbeatPeriod: params.additionalParams?.heartbeatPeriod,
-            });
+            if (params.additionalParams?.heartbeatPeriod) {
+                Object.assign(payload, {
+                    heartbeatPeriod: params.additionalParams?.heartbeatPeriod,
+                });
+            }
         }
 
         const tlsParams: Record<string, unknown> = {};

src/modules/subscription/utils/format-hosts.ts

@@ -105,15 +105,15 @@ export class FormatHosts {
             const port = inputHost.port;
             const network = inbound.streamSettings?.network || 'tcp';
 
-            let streamSettings: WebSocketObject | xHttpObject | RawObject | TcpObject;
+            let streamSettings: WebSocketObject | xHttpObject | RawObject | TcpObject | undefined;
             let pathFromConfig: string | undefined;
             let hostFromConfig: string | undefined;
             let additionalParams: FormattedHosts['additionalParams'] | undefined;
             let headerType: string | undefined;
 
             switch (network) {
                 case 'xhttp': {
-                    const settings = inbound.streamSettings!.xhttpSettings as xHttpObject;
+                    const settings = inbound.streamSettings?.xhttpSettings as xHttpObject;
                     streamSettings = settings;
                     pathFromConfig = settings?.path;
                     hostFromConfig = settings?.host;
@@ -131,20 +131,20 @@ export class FormatHosts {
                     break;
                 }
                 case 'ws': {
-                    const settings = inbound.streamSettings!.wsSettings as WebSocketObject;
+                    const settings = inbound.streamSettings?.wsSettings as WebSocketObject;
                     streamSettings = settings;
                     pathFromConfig = settings?.path;
                     break;
                 }
                 case 'raw':
-                    streamSettings = inbound.streamSettings!.rawSettings as RawObject;
+                    streamSettings = inbound.streamSettings?.rawSettings as RawObject;
                     break;
                 case 'tcp': {
                     if (inbound.protocol === 'shadowsocks') {
                         break;
                     }
 
-                    const settings = inbound.streamSettings!.tcpSettings as TcpObject;
+                    const settings = inbound.streamSettings?.tcpSettings as TcpObject;
                     streamSettings = settings;
                     headerType = settings?.header?.type;
 
@@ -262,7 +262,7 @@ export class FormatHosts {
         try {
             return new FormatHosts(config, hosts, user, configService).generate();
         } catch (error) {
-            console.log(error);
+            // silence error
             return [];
         }
     }

src/modules/xray-config/xray-config.service.ts

@@ -264,16 +264,17 @@ export class XrayConfigService {
                         return securityChanged || networkChanged;
                     })
                     .map((configInbound) => {
-                        const existingInbound = existingInbounds.response!.find(
+                        const existingInbound = existingInbounds.response?.find(
                             (ei) => ei.tag === configInbound.tag,
-                        )!;
-                        return {
-                            uuid: existingInbound.uuid,
-                            tag: existingInbound.tag,
-                            type: existingInbound.type,
-                            security: configInbound.security || null,
-                            network: configInbound.network || null,
-                        };
+                        );
+
+                        // TODO: check this
+
+                        if (!existingInbound) {
+                            throw new Error(`Inbound with tag ${configInbound.tag} not found`);
+                        }
+
+                        return existingInbound;
                     });
 
                 if (inboundsToUpdate.length) {
@@ -294,7 +295,7 @@ export class XrayConfigService {
                 return;
             }
 
-            this.logger.log('Inbounds synced successfully');
+            this.logger.log('Inbounds synced/updated successfully');
         } catch (error) {
             if (error instanceof Error) {
                 this.logger.error('Failed to sync inbounds:', error.message);