@mytmpvpn/mytmpvpn-common 13.0.0 → 16.0.0

package/dist/src/models/vpn.js

@@ -220,7 +220,7 @@ function vpnIdToWgFileName(vpn) {
     const result = vpn.createdAt.toISOString() // This will create YYYY-MM-DDThh:mm:ss....
         .replace(/[^\d]/g, '') // Remove meanless characters: YYYYMMDDhhmmss
         .substring(4, 14); // Use only MMDDhhmmss
-    return result;
+    return `${result}.conf`;
 }
 exports.vpnIdToWgFileName = vpnIdToWgFileName;
 function vpnToClient(vpn) {

package/dist/src/models/websocket.d.ts

@@ -0,0 +1,196 @@
+import { VpnState } from './vpn';
+/**
+ * WebSocket Message Protocol Types
+ *
+ * This module defines the complete message protocol for WebSocket communication
+ * between clients and the backend for real-time VPN state notifications.
+ */
+/**
+ * Base interface for all client-to-server messages
+ */
+export interface BaseClientMessage {
+    action: string;
+    requestId: string;
+}
+/**
+ * Subscribe to VPN state change notifications
+ * - vpnId: specific VPN ID to subscribe to, or "all" for all user VPNs
+ */
+export interface SubscribeMessage extends BaseClientMessage {
+    action: 'subscribe';
+    vpnId: string | 'all';
+}
+/**
+ * Unsubscribe from VPN state change notifications
+ */
+export interface UnsubscribeMessage extends BaseClientMessage {
+    action: 'unsubscribe';
+    vpnId: string;
+}
+/**
+ * Ping message to keep connection alive
+ */
+export interface PingMessage extends BaseClientMessage {
+    action: 'ping';
+}
+/**
+ * Union type of all possible client messages
+ */
+export type ClientMessage = SubscribeMessage | UnsubscribeMessage | PingMessage;
+/**
+ * Base interface for all server-to-client messages
+ */
+export interface BaseServerMessage {
+    type: string;
+    timestamp: number;
+}
+/**
+ * VPN state change notification sent to subscribed clients
+ */
+export interface StateChangeNotification extends BaseServerMessage {
+    type: 'state_change';
+    vpnId: string;
+    previousState: VpnState;
+    newState: VpnState;
+}
+/**
+ * Acknowledgment message for successful operations
+ */
+export interface AcknowledgmentMessage extends BaseServerMessage {
+    type: 'ack';
+    requestId: string;
+    action: string;
+    success: boolean;
+    message?: string;
+}
+/**
+ * Error message for failed operations
+ */
+export interface ErrorMessage extends BaseServerMessage {
+    type: 'error';
+    code: WebSocketErrorCode;
+    message: string;
+    requestId?: string;
+}
+/**
+ * Pong response to ping message
+ */
+export interface PongMessage extends BaseServerMessage {
+    type: 'pong';
+    requestId: string;
+}
+/**
+ * Union type of all possible server messages
+ */
+export type ServerMessage = StateChangeNotification | AcknowledgmentMessage | ErrorMessage | PongMessage;
+/**
+ * Standard error codes for WebSocket operations
+ */
+export declare enum WebSocketErrorCode {
+    AUTHENTICATION_FAILED = "AUTHENTICATION_FAILED",
+    TOKEN_EXPIRED = "TOKEN_EXPIRED",
+    TOKEN_INVALID = "TOKEN_INVALID",
+    TOKEN_MISSING = "TOKEN_MISSING",
+    PERMISSION_DENIED = "PERMISSION_DENIED",
+    VPN_NOT_OWNED = "VPN_NOT_OWNED",
+    INVALID_MESSAGE_FORMAT = "INVALID_MESSAGE_FORMAT",
+    INVALID_VPN_ID = "INVALID_VPN_ID",
+    MISSING_REQUIRED_FIELD = "MISSING_REQUIRED_FIELD",
+    UNKNOWN_ACTION = "UNKNOWN_ACTION",
+    VPN_NOT_FOUND = "VPN_NOT_FOUND",
+    SUBSCRIPTION_NOT_FOUND = "SUBSCRIPTION_NOT_FOUND",
+    RATE_LIMIT_EXCEEDED = "RATE_LIMIT_EXCEEDED",
+    TOO_MANY_MALFORMED_MESSAGES = "TOO_MANY_MALFORMED_MESSAGES",
+    CONNECTION_FAILED = "CONNECTION_FAILED",
+    CONNECTION_TIMEOUT = "CONNECTION_TIMEOUT",
+    INTERNAL_ERROR = "INTERNAL_ERROR",
+    NOTIFICATION_DELIVERY_FAILED = "NOTIFICATION_DELIVERY_FAILED"
+}
+/**
+ * WebSocket connection record stored in DynamoDB
+ */
+export interface ConnectionRecord {
+    connectionId: string;
+    userId: string;
+    connectedAt: number;
+    lastPingAt?: number;
+    ttl: number;
+}
+/**
+ * WebSocket subscription record stored in DynamoDB
+ */
+export interface SubscriptionRecord {
+    subscriptionId: string;
+    connectionId: string;
+    userId: string;
+    vpnId: string;
+    subscribedAt: number;
+    ttl: number;
+}
+/**
+ * VPN state change event published to EventBridge
+ */
+export interface VpnStateChangeEvent {
+    version: '0';
+    id: string;
+    'detail-type': 'VPN State Change';
+    source: 'mytmpvpn.vpn';
+    account: string;
+    time: string;
+    region: string;
+    resources: string[];
+    detail: VpnStateChangeEventDetail;
+}
+/**
+ * Detail section of VPN state change event
+ */
+export interface VpnStateChangeEventDetail {
+    vpnId: string;
+    userId: string;
+    locationId?: string;
+    geonamesId?: number;
+    previousState: VpnState;
+    newState: VpnState;
+    timestamp: number;
+    metadata?: Record<string, any>;
+}
+/**
+ * Configuration for WebSocket client
+ */
+export interface WebSocketConfig {
+    websocketUrl: string;
+    getAuthToken: () => Promise<string>;
+    reconnect?: boolean;
+    reconnectDelay?: number;
+    maxReconnectAttempts?: number;
+}
+/**
+ * WebSocket connection state
+ */
+export declare enum WebSocketConnectionState {
+    DISCONNECTED = "DISCONNECTED",
+    CONNECTING = "CONNECTING",
+    CONNECTED = "CONNECTED",
+    RECONNECTING = "RECONNECTING",
+    FAILED = "FAILED"
+}
+/**
+ * Callback function for state change events
+ */
+export type StateChangeCallback = (event: StateChangeNotification) => void;
+/**
+ * Callback function for error events
+ */
+export type ErrorCallback = (error: ErrorMessage) => void;
+/**
+ * Callback function for connection state changes
+ */
+export type ConnectionStateCallback = (state: WebSocketConnectionState) => void;
+/**
+ * Options for waiting for a specific VPN state
+ */
+export interface WaitForStateOptions {
+    vpnId: string;
+    targetState: VpnState;
+    timeoutMs?: number;
+}

package/dist/src/models/websocket.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketConnectionState = exports.WebSocketErrorCode = void 0;
+// ============================================================================
+// Error Codes
+// ============================================================================
+/**
+ * Standard error codes for WebSocket operations
+ */
+var WebSocketErrorCode;
+(function (WebSocketErrorCode) {
+    // Authentication errors
+    WebSocketErrorCode["AUTHENTICATION_FAILED"] = "AUTHENTICATION_FAILED";
+    WebSocketErrorCode["TOKEN_EXPIRED"] = "TOKEN_EXPIRED";
+    WebSocketErrorCode["TOKEN_INVALID"] = "TOKEN_INVALID";
+    WebSocketErrorCode["TOKEN_MISSING"] = "TOKEN_MISSING";
+    // Authorization errors
+    WebSocketErrorCode["PERMISSION_DENIED"] = "PERMISSION_DENIED";
+    WebSocketErrorCode["VPN_NOT_OWNED"] = "VPN_NOT_OWNED";
+    // Validation errors
+    WebSocketErrorCode["INVALID_MESSAGE_FORMAT"] = "INVALID_MESSAGE_FORMAT";
+    WebSocketErrorCode["INVALID_VPN_ID"] = "INVALID_VPN_ID";
+    WebSocketErrorCode["MISSING_REQUIRED_FIELD"] = "MISSING_REQUIRED_FIELD";
+    WebSocketErrorCode["UNKNOWN_ACTION"] = "UNKNOWN_ACTION";
+    // Resource errors
+    WebSocketErrorCode["VPN_NOT_FOUND"] = "VPN_NOT_FOUND";
+    WebSocketErrorCode["SUBSCRIPTION_NOT_FOUND"] = "SUBSCRIPTION_NOT_FOUND";
+    // Rate limiting
+    WebSocketErrorCode["RATE_LIMIT_EXCEEDED"] = "RATE_LIMIT_EXCEEDED";
+    WebSocketErrorCode["TOO_MANY_MALFORMED_MESSAGES"] = "TOO_MANY_MALFORMED_MESSAGES";
+    // Connection errors
+    WebSocketErrorCode["CONNECTION_FAILED"] = "CONNECTION_FAILED";
+    WebSocketErrorCode["CONNECTION_TIMEOUT"] = "CONNECTION_TIMEOUT";
+    // Internal errors
+    WebSocketErrorCode["INTERNAL_ERROR"] = "INTERNAL_ERROR";
+    WebSocketErrorCode["NOTIFICATION_DELIVERY_FAILED"] = "NOTIFICATION_DELIVERY_FAILED";
+})(WebSocketErrorCode = exports.WebSocketErrorCode || (exports.WebSocketErrorCode = {}));
+/**
+ * WebSocket connection state
+ */
+var WebSocketConnectionState;
+(function (WebSocketConnectionState) {
+    WebSocketConnectionState["DISCONNECTED"] = "DISCONNECTED";
+    WebSocketConnectionState["CONNECTING"] = "CONNECTING";
+    WebSocketConnectionState["CONNECTED"] = "CONNECTED";
+    WebSocketConnectionState["RECONNECTING"] = "RECONNECTING";
+    WebSocketConnectionState["FAILED"] = "FAILED";
+})(WebSocketConnectionState = exports.WebSocketConnectionState || (exports.WebSocketConnectionState = {}));

package/dist/test/models/websocket.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/models/websocket.test.js

@@ -0,0 +1,203 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vpn_1 = require("../../src/models/vpn");
+const websocket_1 = require("../../src/models/websocket");
+describe('WebSocket Types', () => {
+    describe('Client Messages', () => {
+        it('should create a valid SubscribeMessage', () => {
+            const message = {
+                action: 'subscribe',
+                vpnId: 'test-vpn-id',
+                requestId: 'req-123',
+            };
+            expect(message.action).toBe('subscribe');
+            expect(message.vpnId).toBe('test-vpn-id');
+        });
+        it('should create a SubscribeMessage with "all"', () => {
+            const message = {
+                action: 'subscribe',
+                vpnId: 'all',
+                requestId: 'req-123',
+            };
+            expect(message.vpnId).toBe('all');
+        });
+        it('should create a valid UnsubscribeMessage', () => {
+            const message = {
+                action: 'unsubscribe',
+                vpnId: 'test-vpn-id',
+                requestId: 'req-456',
+            };
+            expect(message.action).toBe('unsubscribe');
+        });
+        it('should create a valid PingMessage', () => {
+            const message = {
+                action: 'ping',
+                requestId: 'req-789',
+            };
+            expect(message.action).toBe('ping');
+        });
+        it('should accept ClientMessage union type', () => {
+            const messages = [
+                { action: 'subscribe', vpnId: 'vpn-1', requestId: 'req-1' },
+                { action: 'unsubscribe', vpnId: 'vpn-2', requestId: 'req-2' },
+                { action: 'ping', requestId: 'req-3' },
+            ];
+            expect(messages).toHaveLength(3);
+        });
+    });
+    describe('Server Messages', () => {
+        it('should create a valid StateChangeNotification', () => {
+            const notification = {
+                type: 'state_change',
+                vpnId: 'test-vpn-id',
+                previousState: vpn_1.VpnState.Provisioning,
+                newState: vpn_1.VpnState.Running,
+                timestamp: Date.now(),
+            };
+            expect(notification.type).toBe('state_change');
+            expect(notification.newState).toBe(vpn_1.VpnState.Running);
+        });
+        it('should create a valid AcknowledgmentMessage', () => {
+            const ack = {
+                type: 'ack',
+                requestId: 'req-123',
+                action: 'subscribe',
+                success: true,
+                timestamp: Date.now(),
+            };
+            expect(ack.success).toBe(true);
+        });
+        it('should create a valid ErrorMessage', () => {
+            const error = {
+                type: 'error',
+                code: websocket_1.WebSocketErrorCode.VPN_NOT_FOUND,
+                message: 'VPN not found',
+                requestId: 'req-456',
+                timestamp: Date.now(),
+            };
+            expect(error.code).toBe(websocket_1.WebSocketErrorCode.VPN_NOT_FOUND);
+        });
+        it('should create a valid PongMessage', () => {
+            const pong = {
+                type: 'pong',
+                requestId: 'req-789',
+                timestamp: Date.now(),
+            };
+            expect(pong.type).toBe('pong');
+        });
+        it('should accept ServerMessage union type', () => {
+            const messages = [
+                {
+                    type: 'state_change',
+                    vpnId: 'vpn-1',
+                    previousState: vpn_1.VpnState.Creating,
+                    newState: vpn_1.VpnState.Running,
+                    timestamp: Date.now(),
+                },
+                {
+                    type: 'ack',
+                    requestId: 'req-1',
+                    action: 'subscribe',
+                    success: true,
+                    timestamp: Date.now(),
+                },
+                {
+                    type: 'error',
+                    code: websocket_1.WebSocketErrorCode.INTERNAL_ERROR,
+                    message: 'Error',
+                    timestamp: Date.now(),
+                },
+                {
+                    type: 'pong',
+                    requestId: 'req-2',
+                    timestamp: Date.now(),
+                },
+            ];
+            expect(messages).toHaveLength(4);
+        });
+    });
+    describe('Error Codes', () => {
+        it('should have authentication error codes', () => {
+            expect(websocket_1.WebSocketErrorCode.AUTHENTICATION_FAILED).toBe('AUTHENTICATION_FAILED');
+            expect(websocket_1.WebSocketErrorCode.TOKEN_EXPIRED).toBe('TOKEN_EXPIRED');
+            expect(websocket_1.WebSocketErrorCode.TOKEN_INVALID).toBe('TOKEN_INVALID');
+            expect(websocket_1.WebSocketErrorCode.TOKEN_MISSING).toBe('TOKEN_MISSING');
+        });
+        it('should have authorization error codes', () => {
+            expect(websocket_1.WebSocketErrorCode.PERMISSION_DENIED).toBe('PERMISSION_DENIED');
+            expect(websocket_1.WebSocketErrorCode.VPN_NOT_OWNED).toBe('VPN_NOT_OWNED');
+        });
+        it('should have validation error codes', () => {
+            expect(websocket_1.WebSocketErrorCode.INVALID_MESSAGE_FORMAT).toBe('INVALID_MESSAGE_FORMAT');
+            expect(websocket_1.WebSocketErrorCode.INVALID_VPN_ID).toBe('INVALID_VPN_ID');
+        });
+    });
+    describe('DynamoDB Records', () => {
+        it('should create a valid ConnectionRecord', () => {
+            const record = {
+                connectionId: 'conn-123',
+                userId: 'user-456',
+                connectedAt: Date.now(),
+                ttl: Date.now() + 7200000, // 2 hours
+            };
+            expect(record.connectionId).toBe('conn-123');
+            expect(record.userId).toBe('user-456');
+        });
+        it('should create a valid SubscriptionRecord', () => {
+            const record = {
+                subscriptionId: 'conn-123#vpn-456',
+                connectionId: 'conn-123',
+                userId: 'user-789',
+                vpnId: 'vpn-456',
+                subscribedAt: Date.now(),
+                ttl: Date.now() + 7200000,
+            };
+            expect(record.subscriptionId).toBe('conn-123#vpn-456');
+            expect(record.vpnId).toBe('vpn-456');
+        });
+        it('should support "all" subscription', () => {
+            const record = {
+                subscriptionId: 'conn-123#all',
+                connectionId: 'conn-123',
+                userId: 'user-789',
+                vpnId: 'all',
+                subscribedAt: Date.now(),
+                ttl: Date.now() + 7200000,
+            };
+            expect(record.vpnId).toBe('all');
+        });
+    });
+    describe('EventBridge Events', () => {
+        it('should create a valid VpnStateChangeEvent', () => {
+            const event = {
+                version: '0',
+                id: 'event-123',
+                'detail-type': 'VPN State Change',
+                source: 'mytmpvpn.vpn',
+                account: '123456789012',
+                time: new Date().toISOString(),
+                region: 'us-east-1',
+                resources: [],
+                detail: {
+                    vpnId: 'vpn-123',
+                    userId: 'user-456',
+                    geonamesId: 5128581,
+                    previousState: vpn_1.VpnState.Provisioning,
+                    newState: vpn_1.VpnState.Running,
+                    timestamp: Date.now(),
+                },
+            };
+            expect(event.source).toBe('mytmpvpn.vpn');
+            expect(event.detail.newState).toBe(vpn_1.VpnState.Running);
+        });
+    });
+    describe('Connection States', () => {
+        it('should have all connection states', () => {
+            expect(websocket_1.WebSocketConnectionState.DISCONNECTED).toBe('DISCONNECTED');
+            expect(websocket_1.WebSocketConnectionState.CONNECTING).toBe('CONNECTING');
+            expect(websocket_1.WebSocketConnectionState.CONNECTED).toBe('CONNECTED');
+            expect(websocket_1.WebSocketConnectionState.RECONNECTING).toBe('RECONNECTING');
+            expect(websocket_1.WebSocketConnectionState.FAILED).toBe('FAILED');
+        });
+    });
+});

package/dist/test/models.test.js

@@ -126,6 +126,7 @@ describe('Testing vpnId to Wireguard file name functions ', () => {
         const fileName = (0, vpn_1.vpnIdToWgFileName)(vpn);
         expect(fileName).toBeDefined();
         expect(fileName.length).toBeLessThanOrEqual(15);
+        expect(fileName.endsWith('.conf')).toBe(true);
     });
 });
 describe('Testing vpn config', () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mytmpvpn/mytmpvpn-common",
-  "version": "13.0.0",
+  "version": "16.0.0",
   "description": "Common library for all MyTmpVpn related projects",
   "types": "dist/src/index.d.ts",
   "files": [