exnet-routing 1.2.14 → 1.2.16

package/dist/core/events/_type.d.ts

@@ -0,0 +1,63 @@
+import { z } from "zod";
+export declare const WsCategory: {
+    readonly SUCCESS: "success";
+    readonly ERROR: "error";
+    readonly WARNING: "warning";
+    readonly INFO: "info";
+};
+export type WsCategoryType = (typeof WsCategory)[keyof typeof WsCategory];
+export declare const WsBasePayloadSchema: z.ZodObject<{
+    message: z.ZodString;
+    category: z.ZodEnum<["success", "error", "warning", "info"]>;
+    type: z.ZodString;
+    data: z.ZodRecord<z.ZodString, z.ZodAny>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    type: string;
+    category: "error" | "success" | "info" | "warning";
+    data: Record<string, any>;
+}, {
+    message: string;
+    type: string;
+    category: "error" | "success" | "info" | "warning";
+    data: Record<string, any>;
+}>;
+export type WsBasePayload = z.infer<typeof WsBasePayloadSchema>;
+export type IWsEvent<T extends z.ZodObject<any> = z.ZodObject<any>> = {
+    event: string;
+    type: string;
+    category: WsCategoryType;
+    payload: T;
+    description?: string;
+    rooms?: string[];
+};
+export type NestedEvents = {
+    [K: string]: NestedEvents | IWsEvent;
+};
+export declare const IWsEventType: <T extends NestedEvents>(events: T) => T;
+export declare const defineEvent: <T extends z.ZodObject<any>>(event: {
+    event: string;
+    type: string;
+    category: WsCategoryType;
+    payload: T;
+    description?: string;
+    rooms?: string[];
+}) => IWsEvent<T>;
+export declare const isWsEvent: (value: NestedEvents | IWsEvent) => value is IWsEvent;
+export declare const isNestedEvents: (value: NestedEvents | IWsEvent) => value is NestedEvents;
+export type TransformEvents<T extends NestedEvents> = {
+    [K in keyof T]: T[K] extends NestedEvents ? TransformEvents<T[K]> : T[K] extends IWsEvent<infer P> ? {
+        /** Subscribe to this event */
+        on: (callback: (data: z.infer<P>) => void) => () => void;
+        /** Emit this event (for testing/mocking) */
+        emit: (data: z.infer<P>) => void;
+        /** Event name */
+        eventName: string;
+        /** Event type */
+        eventType: string;
+        /** Payload schema for validation */
+        schema: P;
+    } : never;
+};
+export type EventHandler<T extends z.ZodObject<any>> = (data: z.infer<T>) => void;
+export type UnsubscribeFn = () => void;

package/dist/core/events/_type.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNestedEvents = exports.isWsEvent = exports.defineEvent = exports.IWsEventType = exports.WsBasePayloadSchema = exports.WsCategory = void 0;
+const zod_1 = require("zod");
+// WebSocket event categories
+exports.WsCategory = {
+    SUCCESS: "success",
+    ERROR: "error",
+    WARNING: "warning",
+    INFO: "info",
+};
+// Base payload schema for all events
+exports.WsBasePayloadSchema = zod_1.z.object({
+    message: zod_1.z.string(),
+    category: zod_1.z.enum(["success", "error", "warning", "info"]),
+    type: zod_1.z.string(),
+    data: zod_1.z.record(zod_1.z.any()),
+});
+// Helper to create event definitions
+const IWsEventType = (events) => events;
+exports.IWsEventType = IWsEventType;
+// Helper to create a single event
+const defineEvent = (event) => event;
+exports.defineEvent = defineEvent;
+// Check if value is an event definition
+const isWsEvent = (value) => {
+    return "event" in value && "type" in value && "payload" in value;
+};
+exports.isWsEvent = isWsEvent;
+// Check if value is a nested events group
+const isNestedEvents = (value) => {
+    return !(0, exports.isWsEvent)(value);
+};
+exports.isNestedEvents = isNestedEvents;

package/dist/core/events/_utils.d.ts

@@ -0,0 +1,5 @@
+import { Socket } from "socket.io-client";
+import { IWsEvent, NestedEvents, TransformEvents } from "./_type";
+export declare const parseWsEvents: <T extends NestedEvents>(events: T, socket: Socket) => TransformEvents<T>;
+export declare const getAllEventNames: (events: NestedEvents, prefix?: string) => string[];
+export declare const getEventByName: (events: NestedEvents, eventName: string) => IWsEvent | undefined;

package/dist/core/events/_utils.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEventByName = exports.getAllEventNames = exports.parseWsEvents = void 0;
+const _type_1 = require("./_type");
+// Create event handler wrapper with validation
+const createEventHandler = (socket, event) => {
+    return {
+        on: (callback) => {
+            const handler = (data) => {
+                // Validate incoming data against schema
+                const result = event.payload.safeParse(data);
+                if (result.success) {
+                    callback(result.data);
+                }
+                else {
+                    console.warn(`[WS] Invalid payload for event ${event.event}:`, result.error.errors);
+                }
+            };
+            socket.on(event.event, handler);
+            // Return unsubscribe function
+            return () => {
+                socket.off(event.event, handler);
+            };
+        },
+        emit: (data) => {
+            // Validate outgoing data
+            const result = event.payload.safeParse(data);
+            if (result.success) {
+                socket.emit(event.event, result.data);
+            }
+            else {
+                console.error(`[WS] Invalid payload for emit ${event.event}:`, result.error.errors);
+            }
+        },
+        eventName: event.event,
+        eventType: event.type,
+        schema: event.payload,
+    };
+};
+// Parse nested events recursively
+const parseWsEvents = (events, socket) => {
+    const result = {};
+    for (const [key, value] of Object.entries(events)) {
+        if ((0, _type_1.isWsEvent)(value)) {
+            ;
+            result[key] = createEventHandler(socket, value);
+        }
+        else if ((0, _type_1.isNestedEvents)(value)) {
+            ;
+            result[key] = (0, exports.parseWsEvents)(value, socket);
+        }
+    }
+    return result;
+};
+exports.parseWsEvents = parseWsEvents;
+// Get all event names from nested events (useful for debugging)
+const getAllEventNames = (events, prefix = "") => {
+    const names = [];
+    for (const [key, value] of Object.entries(events)) {
+        const path = prefix ? `${prefix}.${key}` : key;
+        if ((0, _type_1.isWsEvent)(value)) {
+            names.push(`${path}: ${value.event}`);
+        }
+        else if ((0, _type_1.isNestedEvents)(value)) {
+            names.push(...(0, exports.getAllEventNames)(value, path));
+        }
+    }
+    return names;
+};
+exports.getAllEventNames = getAllEventNames;
+// Get event by name (for dynamic access)
+const getEventByName = (events, eventName) => {
+    for (const value of Object.values(events)) {
+        if ((0, _type_1.isWsEvent)(value) && value.event === eventName) {
+            return value;
+        }
+        else if ((0, _type_1.isNestedEvents)(value)) {
+            const found = (0, exports.getEventByName)(value, eventName);
+            if (found)
+                return found;
+        }
+    }
+    return undefined;
+};
+exports.getEventByName = getEventByName;

package/dist/core/events/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./_type";
+export * from "./_utils";

package/dist/core/events/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./_type"), exports);
+__exportStar(require("./_utils"), exports);

package/dist/events/_chat.d.ts

@@ -0,0 +1,117 @@
+import { z } from "zod";
+export declare const chatEvents: {
+    messageCreated: import("../core/events/_type").IWsEvent<z.ZodObject<{
+        message: z.ZodString;
+        category: z.ZodLiteral<"info">;
+        type: z.ZodLiteral<"chat_message_created">;
+        data: z.ZodObject<{
+            chatId: z.ZodNumber;
+            message: z.ZodRecord<z.ZodString, z.ZodAny>;
+            createdAt: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            createdAt: string;
+            message: Record<string, any>;
+            chatId: number;
+        }, {
+            createdAt: string;
+            message: Record<string, any>;
+            chatId: number;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        type: "chat_message_created";
+        category: "info";
+        data: {
+            createdAt: string;
+            message: Record<string, any>;
+            chatId: number;
+        };
+    }, {
+        message: string;
+        type: "chat_message_created";
+        category: "info";
+        data: {
+            createdAt: string;
+            message: Record<string, any>;
+            chatId: number;
+        };
+    }>>;
+    messageRead: import("../core/events/_type").IWsEvent<z.ZodObject<{
+        message: z.ZodString;
+        category: z.ZodLiteral<"info">;
+        type: z.ZodLiteral<"chat_message_read">;
+        data: z.ZodObject<{
+            chatId: z.ZodNumber;
+            messageId: z.ZodNumber;
+            userId: z.ZodNumber;
+            readAt: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            userId: number;
+            chatId: number;
+            messageId: number;
+            readAt: string;
+        }, {
+            userId: number;
+            chatId: number;
+            messageId: number;
+            readAt: string;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        type: "chat_message_read";
+        category: "info";
+        data: {
+            userId: number;
+            chatId: number;
+            messageId: number;
+            readAt: string;
+        };
+    }, {
+        message: string;
+        type: "chat_message_read";
+        category: "info";
+        data: {
+            userId: number;
+            chatId: number;
+            messageId: number;
+            readAt: string;
+        };
+    }>>;
+    typing: import("../core/events/_type").IWsEvent<z.ZodObject<{
+        message: z.ZodString;
+        category: z.ZodLiteral<"info">;
+        type: z.ZodLiteral<"chat_typing">;
+        data: z.ZodObject<{
+            chatId: z.ZodNumber;
+            userId: z.ZodNumber;
+            isTyping: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            userId: number;
+            chatId: number;
+            isTyping: boolean;
+        }, {
+            userId: number;
+            chatId: number;
+            isTyping: boolean;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        type: "chat_typing";
+        category: "info";
+        data: {
+            userId: number;
+            chatId: number;
+            isTyping: boolean;
+        };
+    }, {
+        message: string;
+        type: "chat_typing";
+        category: "info";
+        data: {
+            userId: number;
+            chatId: number;
+            isTyping: boolean;
+        };
+    }>>;
+};
+export type ChatEventsType = typeof chatEvents;

package/dist/events/_chat.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chatEvents = void 0;
+const zod_1 = require("zod");
+const _type_1 = require("../core/events/_type");
+// Chat payload schemas
+const ChatMessageCreatedPayload = zod_1.z.object({
+    message: zod_1.z.string(),
+    category: zod_1.z.literal(_type_1.WsCategory.INFO),
+    type: zod_1.z.literal("chat_message_created"),
+    data: zod_1.z.object({
+        chatId: zod_1.z.number(),
+        message: zod_1.z.record(zod_1.z.any()),
+        createdAt: zod_1.z.string(),
+    }),
+});
+const ChatMessageReadPayload = zod_1.z.object({
+    message: zod_1.z.string(),
+    category: zod_1.z.literal(_type_1.WsCategory.INFO),
+    type: zod_1.z.literal("chat_message_read"),
+    data: zod_1.z.object({
+        chatId: zod_1.z.number(),
+        messageId: zod_1.z.number(),
+        userId: zod_1.z.number(),
+        readAt: zod_1.z.string(),
+    }),
+});
+const ChatTypingPayload = zod_1.z.object({
+    message: zod_1.z.string(),
+    category: zod_1.z.literal(_type_1.WsCategory.INFO),
+    type: zod_1.z.literal("chat_typing"),
+    data: zod_1.z.object({
+        chatId: zod_1.z.number(),
+        userId: zod_1.z.number(),
+        isTyping: zod_1.z.boolean(),
+    }),
+});
+// Export chat events definitions
+exports.chatEvents = (0, _type_1.IWsEventType)({
+    messageCreated: (0, _type_1.defineEvent)({
+        event: "chat:message_created",
+        type: "chat_message_created",
+        category: _type_1.WsCategory.INFO,
+        payload: ChatMessageCreatedPayload,
+        description: "Emitted when a new chat message is created",
+        rooms: ["chat:{chatId}", "user:{userId}"],
+    }),
+    messageRead: (0, _type_1.defineEvent)({
+        event: "chat:message_read",
+        type: "chat_message_read",
+        category: _type_1.WsCategory.INFO,
+        payload: ChatMessageReadPayload,
+        description: "Emitted when a message is marked as read",
+        rooms: ["chat:{chatId}"],
+    }),
+    typing: (0, _type_1.defineEvent)({
+        event: "chat:typing",
+        type: "chat_typing",
+        category: _type_1.WsCategory.INFO,
+        payload: ChatTypingPayload,
+        description: "Emitted when a user is typing in a chat",
+        rooms: ["chat:{chatId}"],
+    }),
+});

package/dist/events/_driver.d.ts

@@ -0,0 +1,152 @@
+import { z } from "zod";
+export declare const driverEvents: {
+    pickupConfirmed: import("../core/events/_type").IWsEvent<z.ZodObject<{
+        message: z.ZodString;
+        category: z.ZodLiteral<"success">;
+        type: z.ZodLiteral<"driver_pickup_confirmed">;
+        data: z.ZodObject<{
+            shippingId: z.ZodNumber;
+            driverId: z.ZodNumber;
+            nom: z.ZodOptional<z.ZodString>;
+            prenom: z.ZodOptional<z.ZodString>;
+            signature: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            picture: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            date: z.ZodOptional<z.ZodString>;
+            heurs: z.ZodOptional<z.ZodString>;
+            confirmedAt: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            shippingId: number;
+            driverId: number;
+            confirmedAt: string;
+            date?: string | undefined;
+            nom?: string | undefined;
+            prenom?: string | undefined;
+            signature?: string | null | undefined;
+            heurs?: string | undefined;
+            picture?: string | null | undefined;
+        }, {
+            shippingId: number;
+            driverId: number;
+            confirmedAt: string;
+            date?: string | undefined;
+            nom?: string | undefined;
+            prenom?: string | undefined;
+            signature?: string | null | undefined;
+            heurs?: string | undefined;
+            picture?: string | null | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        type: "driver_pickup_confirmed";
+        category: "success";
+        data: {
+            shippingId: number;
+            driverId: number;
+            confirmedAt: string;
+            date?: string | undefined;
+            nom?: string | undefined;
+            prenom?: string | undefined;
+            signature?: string | null | undefined;
+            heurs?: string | undefined;
+            picture?: string | null | undefined;
+        };
+    }, {
+        message: string;
+        type: "driver_pickup_confirmed";
+        category: "success";
+        data: {
+            shippingId: number;
+            driverId: number;
+            confirmedAt: string;
+            date?: string | undefined;
+            nom?: string | undefined;
+            prenom?: string | undefined;
+            signature?: string | null | undefined;
+            heurs?: string | undefined;
+            picture?: string | null | undefined;
+        };
+    }>>;
+    deliveryConfirmed: import("../core/events/_type").IWsEvent<z.ZodObject<{
+        message: z.ZodString;
+        category: z.ZodLiteral<"success">;
+        type: z.ZodLiteral<"driver_delivery_confirmed">;
+        data: z.ZodObject<{
+            shippingId: z.ZodNumber;
+            driverId: z.ZodNumber;
+            visibleTo: z.ZodOptional<z.ZodBoolean>;
+            confirmedAt: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            shippingId: number;
+            driverId: number;
+            confirmedAt: string;
+            visibleTo?: boolean | undefined;
+        }, {
+            shippingId: number;
+            driverId: number;
+            confirmedAt: string;
+            visibleTo?: boolean | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        type: "driver_delivery_confirmed";
+        category: "success";
+        data: {
+            shippingId: number;
+            driverId: number;
+            confirmedAt: string;
+            visibleTo?: boolean | undefined;
+        };
+    }, {
+        message: string;
+        type: "driver_delivery_confirmed";
+        category: "success";
+        data: {
+            shippingId: number;
+            driverId: number;
+            confirmedAt: string;
+            visibleTo?: boolean | undefined;
+        };
+    }>>;
+    statusChanged: import("../core/events/_type").IWsEvent<z.ZodObject<{
+        message: z.ZodString;
+        category: z.ZodLiteral<"info">;
+        type: z.ZodLiteral<"driver_status_changed">;
+        data: z.ZodObject<{
+            driverId: z.ZodNumber;
+            oldStatus: z.ZodString;
+            newStatus: z.ZodString;
+            changedAt: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            driverId: number;
+            oldStatus: string;
+            newStatus: string;
+            changedAt: string;
+        }, {
+            driverId: number;
+            oldStatus: string;
+            newStatus: string;
+            changedAt: string;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        type: "driver_status_changed";
+        category: "info";
+        data: {
+            driverId: number;
+            oldStatus: string;
+            newStatus: string;
+            changedAt: string;
+        };
+    }, {
+        message: string;
+        type: "driver_status_changed";
+        category: "info";
+        data: {
+            driverId: number;
+            oldStatus: string;
+            newStatus: string;
+            changedAt: string;
+        };
+    }>>;
+};
+export type DriverEventsType = typeof driverEvents;

package/dist/events/_driver.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.driverEvents = void 0;
+const zod_1 = require("zod");
+const _type_1 = require("../core/events/_type");
+// Driver payload schemas
+const DriverPickupConfirmedPayload = zod_1.z.object({
+    message: zod_1.z.string(),
+    category: zod_1.z.literal(_type_1.WsCategory.SUCCESS),
+    type: zod_1.z.literal("driver_pickup_confirmed"),
+    data: zod_1.z.object({
+        shippingId: zod_1.z.number(),
+        driverId: zod_1.z.number(),
+        nom: zod_1.z.string().optional(),
+        prenom: zod_1.z.string().optional(),
+        signature: zod_1.z.string().nullable().optional(),
+        picture: zod_1.z.string().nullable().optional(),
+        date: zod_1.z.string().optional(),
+        heurs: zod_1.z.string().optional(),
+        confirmedAt: zod_1.z.string(),
+    }),
+});
+const DriverDeliveryConfirmedPayload = zod_1.z.object({
+    message: zod_1.z.string(),
+    category: zod_1.z.literal(_type_1.WsCategory.SUCCESS),
+    type: zod_1.z.literal("driver_delivery_confirmed"),
+    data: zod_1.z.object({
+        shippingId: zod_1.z.number(),
+        driverId: zod_1.z.number(),
+        visibleTo: zod_1.z.boolean().optional(),
+        confirmedAt: zod_1.z.string(),
+    }),
+});
+const DriverStatusChangedPayload = zod_1.z.object({
+    message: zod_1.z.string(),
+    category: zod_1.z.literal(_type_1.WsCategory.INFO),
+    type: zod_1.z.literal("driver_status_changed"),
+    data: zod_1.z.object({
+        driverId: zod_1.z.number(),
+        oldStatus: zod_1.z.string(),
+        newStatus: zod_1.z.string(),
+        changedAt: zod_1.z.string(),
+    }),
+});
+// Export driver events definitions
+exports.driverEvents = (0, _type_1.IWsEventType)({
+    pickupConfirmed: (0, _type_1.defineEvent)({
+        event: "driver:pickup_confirmed",
+        type: "driver_pickup_confirmed",
+        category: _type_1.WsCategory.SUCCESS,
+        payload: DriverPickupConfirmedPayload,
+        description: "Emitted when a driver confirms pickup",
+        rooms: ["shipping:{shippingId}", "role:ROLE_OPS_*"],
+    }),
+    deliveryConfirmed: (0, _type_1.defineEvent)({
+        event: "driver:delivery_confirmed",
+        type: "driver_delivery_confirmed",
+        category: _type_1.WsCategory.SUCCESS,
+        payload: DriverDeliveryConfirmedPayload,
+        description: "Emitted when a driver confirms delivery",
+        rooms: ["shipping:{shippingId}", "role:ROLE_OPS_*"],
+    }),
+    statusChanged: (0, _type_1.defineEvent)({
+        event: "driver:status_changed",
+        type: "driver_status_changed",
+        category: _type_1.WsCategory.INFO,
+        payload: DriverStatusChangedPayload,
+        description: "Emitted when driver status changes",
+        rooms: ["role:ROLE_OPS_*"],
+    }),
+});

package/dist/events/_facture.d.ts

@@ -0,0 +1,66 @@
+import { z } from "zod";
+export declare const factureEvents: {
+    created: import("../core/events/_type").IWsEvent<z.ZodObject<{
+        message: z.ZodString;
+        category: z.ZodLiteral<"success">;
+        type: z.ZodLiteral<"facture_created">;
+        data: z.ZodObject<{
+            facture: z.ZodRecord<z.ZodString, z.ZodAny>;
+            createdAt: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            createdAt: string;
+            facture: Record<string, any>;
+        }, {
+            createdAt: string;
+            facture: Record<string, any>;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        type: "facture_created";
+        category: "success";
+        data: {
+            createdAt: string;
+            facture: Record<string, any>;
+        };
+    }, {
+        message: string;
+        type: "facture_created";
+        category: "success";
+        data: {
+            createdAt: string;
+            facture: Record<string, any>;
+        };
+    }>>;
+    updated: import("../core/events/_type").IWsEvent<z.ZodObject<{
+        message: z.ZodString;
+        category: z.ZodLiteral<"info">;
+        type: z.ZodLiteral<"facture_updated">;
+        data: z.ZodObject<{
+            facture: z.ZodRecord<z.ZodString, z.ZodAny>;
+            updatedAt: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            updatedAt: string;
+            facture: Record<string, any>;
+        }, {
+            updatedAt: string;
+            facture: Record<string, any>;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        type: "facture_updated";
+        category: "info";
+        data: {
+            updatedAt: string;
+            facture: Record<string, any>;
+        };
+    }, {
+        message: string;
+        type: "facture_updated";
+        category: "info";
+        data: {
+            updatedAt: string;
+            facture: Record<string, any>;
+        };
+    }>>;
+};
+export type FactureEventsType = typeof factureEvents;