docpouch-client 0.8.3 → 0.8.5

package/dist/index.d.ts

@@ -1,11 +1,61 @@
-import type { I_UserEntry, I_UserLogin, I_UserCreation, I_UserUpdate, I_UserDisplay, I_DocumentEntry, I_DataStructure, I_LoginResponse, I_DocumentQuery, I_StructureCreation, I_WsMessage, I_EventString } from "./types.js";
+import type { I_UserEntry, I_UserLogin, I_UserCreation, I_UserUpdate, I_UserDisplay, I_DocumentEntry, I_DataStructure, I_LoginResponse, I_DocumentQuery, I_StructureCreation, I_WsMessage, I_EventString, I_DocumentType } from "./types.js";
 import { Socket } from "socket.io-client";
-export default class Index {
+/**
+ * Client for interacting with docPouch API.
+ */
+export default class docPouchClient {
+    /**
+     * The base URL of the server.
+     *
+     * @type {string}
+     */
     baseUrl: string;
-    private token;
+    /**
+     * Socket.IO socket instance for real-time communication with the server.
+     *
+     * @type {Socket}
+     */
     socket: Socket;
-    constructor(baseUrl: string, callback?: (event: I_EventString, data: I_WsMessage) => void);
-    private request;
+    /**
+     * Callback function to handle socket events.
+     *
+     * @type {(event: I_EventString, data: I_WsMessage) => void}
+     */
+    callbackFunction: ((event: I_EventString, data: I_WsMessage) => void) | undefined;
+    /**
+     * Flag indicating whether real-time synchronization is enabled.
+     *
+     * @type {boolean}
+     */
+    realTimeSync: boolean;
+    /**
+     * Authentication token used to authorize requests.
+     *
+     * @private
+     * @type {string | null}
+     */
+    private authToken;
+    /**
+     * Flag indicating whether a connection attempt is in progress.
+     *
+     * @private
+     * @type {boolean}
+     */
+    private connectionInProgress;
+    /**
+     * Creates an instance of docPouchClient.
+     *
+     * @param {string} host - The base URL for the server.
+     * @param {number} [port=80] - The port number to connect to (default is 80).
+     * @param {(event: I_EventString, data: I_WsMessage) => void} [callback] - Optional callback function for socket events.
+     */
+    constructor(host: string, port?: number, callback?: (event: I_EventString, data: I_WsMessage) => void);
+    /**
+     * Sets the real-time synchronization status.
+     *
+     * @param {boolean} newRealTimeSync - The new real-time sync setting (true/false).
+     */
+    setRealTimeSync(newRealTimeSync: boolean): void;
     login(credentials: I_UserLogin): Promise<I_LoginResponse | null>;
     listUsers(): Promise<I_UserEntry[]>;
     updateUser(userID: string, userData: I_UserUpdate): Promise<void>;
@@ -20,7 +70,24 @@ export default class Index {
     getStructures(): Promise<I_DataStructure[]>;
     updateStructure(structureID: string, structureData: I_DataStructure): Promise<void>;
     removeStructure(structureID: string): Promise<void>;
+    createType(type: I_DocumentType): Promise<I_DocumentType>;
+    removeType(typeID: string): Promise<void>;
+    getTypes(): Promise<I_DocumentType[]>;
+    updateType(updatedType: I_DocumentType): Promise<void>;
     setToken(token: string | null): void;
-    getToken(): string | null;
     getVersion(): string;
+    debugSocketConnection(): void;
+    /**
+     * Sets up permanent socket listeners for the client.
+     *
+     * @private
+     */
+    private setupPermanentSocketListeners;
+    /**
+     * Initializes the WebSocket connection with the server.
+     *
+     * @private
+     */
+    private initWebSocket;
+    private request;
 }

package/dist/index.js

@@ -1,54 +1,99 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const socket_io_client_1 = require("socket.io-client");
-const package_json_1 = __importDefault(require("../package.json"));
-class Index {
-    constructor(baseUrl, callback) {
-        this.token = null;
-        this.baseUrl = baseUrl;
-        this.socket = (0, socket_io_client_1.io)(baseUrl, { autoConnect: false });
-        if (callback) {
-            this.socket.connect();
-            this.socket.onAny((event, data) => {
-                if (event === "heartbeatPing") {
-                    console.log("Ping event received:", data);
-                    this.socket.emit("heartbeatPong", Date.now());
-                }
-                else {
-                    callback(event, data);
-                }
-            });
-        }
+import { io } from "socket.io-client";
+import packetJson from '../package.json';
+/**
+ * Client for interacting with docPouch API.
+ */
+export default class docPouchClient {
+    /**
+     * Creates an instance of docPouchClient.
+     *
+     * @param {string} host - The base URL for the server.
+     * @param {number} [port=80] - The port number to connect to (default is 80).
+     * @param {(event: I_EventString, data: I_WsMessage) => void} [callback] - Optional callback function for socket events.
+     */
+    constructor(host, port = 80, callback) {
+        /**
+         * Flag indicating whether real-time synchronization is enabled.
+         *
+         * @type {boolean}
+         */
+        this.realTimeSync = false;
+        /**
+         * Authentication token used to authorize requests.
+         *
+         * @private
+         * @type {string | null}
+         */
+        this.authToken = null;
+        /**
+         * Flag indicating whether a connection attempt is in progress.
+         *
+         * @private
+         * @type {boolean}
+         */
+        this.connectionInProgress = false;
+        this.baseUrl = host;
+        const socketUrl = host.includes('://') ? host : `https://${host}`;
+        const socketUrlWithPort = socketUrl.includes(':') && !socketUrl.endsWith(':')
+            ? socketUrl
+            : `${socketUrl}:${port}`;
+        console.log(`Initializing Socket.IO with URL: ${socketUrlWithPort}, path: /socket.io`);
+        this.socket = io(`${socketUrlWithPort}`, {
+            autoConnect: false,
+            transports: ['websocket'], // Try websocket only first
+            reconnection: true,
+            reconnectionAttempts: 5,
+            reconnectionDelay: 1000,
+            forceNew: true, // Force a new connection
+            auth: {
+                token: null // Will be set later
+            },
+            path: '/socket.io'
+        });
+        this.callbackFunction = callback;
+        this.setupPermanentSocketListeners();
     }
-    async request(endpoint, method, body, requiresAuth = true) {
-        const headers = {
-            'Content-Type': 'application/json'
-        };
-        if (requiresAuth && this.token) {
-            headers['Authorization'] = `Bearer ${this.token}`;
+    /**
+     * Sets the real-time synchronization status.
+     *
+     * @param {boolean} newRealTimeSync - The new real-time sync setting (true/false).
+     */
+    setRealTimeSync(newRealTimeSync) {
+        console.log(`Setting realtime sync to: ${newRealTimeSync}. Current setting: ${this.realTimeSync}`);
+        // Skip if the setting isn't changing
+        if (newRealTimeSync === this.realTimeSync) {
+            console.log("Realtime sync setting unchanged, skipping");
+            return;
         }
-        const options = {
-            method,
-            headers,
-            body: body ? JSON.stringify(body) : undefined
-        };
-        const response = await fetch(`${this.baseUrl}${endpoint}`, options);
-        if (!response.ok) {
-            if (response.status === 401 || response.status === 403) {
-                this.token = null;
+        this.realTimeSync = newRealTimeSync;
+        if (newRealTimeSync && this.authToken) {
+            console.log("Activating realtime updates");
+            // Ensure we're not in the middle of another connection attempt
+            if (this.connectionInProgress) {
+                console.log("Connection already in progress, waiting before initializing");
+                setTimeout(() => this.initWebSocket(), 500);
+            }
+            else {
+                this.initWebSocket();
+            }
+        }
+        else if (!newRealTimeSync) {
+            console.log("Deactivating realtime updates");
+            if (this.socket.connected) {
+                console.log("Disconnecting socket");
+                this.socket.disconnect();
             }
-            throw new Error(`API error: ${response.status} ${response.statusText}`);
         }
-        return await response.json();
     }
     // User Administration Endpoints
     async login(credentials) {
         const response = await this.request('/users/login', 'POST', credentials, false);
         if (response.token) {
-            this.token = response.token;
+            this.authToken = response.token;
+            // Reconnect websocket with new token if realtime sync is enabled
+            if (this.realTimeSync) {
+                this.initWebSocket();
+            }
             return { token: response.token, isAdmin: response.isAdmin };
         }
         return null;
@@ -94,15 +139,170 @@ class Index {
     async removeStructure(structureID) {
         await this.request(`/structures/remove/${structureID}`, 'DELETE');
     }
-    setToken(token) {
-        this.token = token;
+    // Data Type Endpoints
+    async createType(type) {
+        return await this.request('/types/write', 'PATCH', type);
     }
-    getToken() {
-        return this.token;
+    async removeType(typeID) {
+        return await this.request(`/types/remove/${typeID}`, 'DELETE');
+    }
+    async getTypes() {
+        return await this.request('/types/list', 'GET');
+    }
+    async updateType(updatedType) {
+        await this.request(`/types/write`, 'PATCH', updatedType);
+    }
+    setToken(token) {
+        console.log("Setting token to:", token ? "***token***" : "null");
+        const tokenChanged = this.authToken !== token;
+        this.authToken = token;
+        if (!tokenChanged) {
+            console.log("Token unchanged, no need to reconnect");
+            return;
+        }
+        // If we have a new token and realtime sync is enabled
+        if (token && this.realTimeSync) {
+            console.log("New token set, will initialize WebSocket");
+            // Ensure any existing connection is closed first
+            if (this.socket.connected) {
+                console.log("Disconnecting existing socket before reconnecting with new token");
+                this.socket.disconnect();
+            }
+            // Wait a moment for the disconnect to complete
+            setTimeout(() => {
+                console.log("Initializing WebSocket with new token");
+                this.initWebSocket();
+            }, 300);
+        }
+        // If token was cleared or realtime sync is disabled
+        else if (this.socket.connected) {
+            console.log("Token cleared or realtime sync disabled, disconnecting");
+            this.socket.disconnect();
+        }
     }
     getVersion() {
-        return package_json_1.default.version;
+        return packetJson.version;
+    }
+    debugSocketConnection() {
+        console.log("Socket connection debug info:");
+        console.log("- Connected:", this.socket.connected);
+        console.log("- Socket ID:", this.socket.id);
+        console.log("- Auth token present:", !!this.authToken);
+        console.log("- Connection in progress:", this.connectionInProgress);
+        console.log("- Realtime sync enabled:", this.realTimeSync);
+        console.log("- Socket options:", this.socket.io.opts);
+        // Try to force reconnection
+        if (!this.socket.connected && this.authToken && this.realTimeSync) {
+            console.log("Attempting to force reconnection...");
+            this.socket.auth = { token: this.authToken };
+            this.socket.connect();
+        }
+    }
+    /**
+     * Sets up permanent socket listeners for the client.
+     *
+     * @private
+     */
+    setupPermanentSocketListeners() {
+        // These are permanent listeners that won't be removed
+        this.socket.on('connect_error', (error) => {
+            console.error('Socket connection error:', error.message);
+            this.connectionInProgress = false;
+        });
+        this.socket.on('connect', () => {
+            console.log('Socket connected successfully with ID:', this.socket.id);
+            this.connectionInProgress = false;
+        });
+        this.socket.on('disconnect', (reason) => {
+            console.log('Socket disconnected. Reason:', reason);
+            this.connectionInProgress = false;
+        });
+        this.socket.on('error', (error) => {
+            console.error('Socket error:', error);
+            this.connectionInProgress = false;
+        });
+    }
+    /**
+     * Initializes the WebSocket connection with the server.
+     *
+     * @private
+     */
+    initWebSocket() {
+        console.log("initWebSocket called. Auth token present:", !!this.authToken, "Connection in progress:", this.connectionInProgress, "Socket connected:", this.socket.connected);
+        if (!this.authToken) {
+            console.log("Skipping WebSocket initialization: No auth token");
+            return;
+        }
+        if (this.connectionInProgress) {
+            console.log("Connection already in progress, skipping initialization");
+            return;
+        }
+        if (this.socket.connected) {
+            console.log("Socket already connected with ID:", this.socket.id);
+            return;
+        }
+        this.connectionInProgress = true;
+        try {
+            console.log("Setting up WebSocket connection with token");
+            // Update the auth token
+            this.socket.auth = { token: this.authToken };
+            // Remove any dynamic event listeners that might have been added
+            this.socket.offAny();
+            // Set up event handler for application events
+            this.socket.onAny((event, data) => {
+                if (event === "heartbeatPing") {
+                    console.log("Ping event received:", data);
+                    this.socket.emit("heartbeatPong", Date.now());
+                }
+                else if (this.callbackFunction) {
+                    this.callbackFunction(event, data);
+                }
+            });
+            // Connect to the server
+            console.log("Connecting socket with auth token");
+            this.socket.connect();
+            // Add a timeout to detect if connection is taking too long
+            setTimeout(() => {
+                if (this.connectionInProgress) {
+                    console.warn("Socket connection attempt timed out after 5 seconds");
+                    this.connectionInProgress = false;
+                    // If we're still not connected after the timeout, try again with polling
+                    if (!this.socket.connected) {
+                        console.log("Retrying connection with polling transport");
+                        this.socket.io.opts.transports = ['polling', 'websocket'];
+                        this.socket.connect();
+                    }
+                }
+            }, 5000);
+        }
+        catch (error) {
+            console.error('Error in initWebSocket:', error);
+            this.connectionInProgress = false;
+        }
+    }
+    async request(endpoint, method, body, requiresAuth = true) {
+        const headers = {
+            'Content-Type': 'application/json',
+        };
+        if (requiresAuth && this.authToken)
+            headers['Authorization'] = `Bearer ${this.authToken}`;
+        if (this.socket.id)
+            headers['X-Socket-ID'] = this.socket.id;
+        const options = {
+            method,
+            headers,
+            body: body ? JSON.stringify(body) : undefined
+        };
+        const normalizedEndpoint = endpoint.startsWith('/') ? endpoint : `/${endpoint}`;
+        const normalizedBaseUrl = this.baseUrl.endsWith('/') ? this.baseUrl.slice(0, -1) : this.baseUrl;
+        const url = `${normalizedBaseUrl}${normalizedEndpoint}`;
+        const response = await fetch(url, options);
+        if (!response.ok) {
+            if (response.status === 401 || response.status === 403) {
+                this.authToken = null;
+            }
+            throw new Error(`API error: ${response.status} ${response.statusText}`);
+        }
+        return await response.json();
     }
 }
-exports.default = Index;
-module.exports = Index;

package/dist/types.d.ts

@@ -84,7 +84,15 @@ export interface I_StructureUpdate {
     reference?: any;
     fields?: any[];
 }
-export type I_EventString = 'subscribe' | 'unsubscribe' | 'heartbeatPong' | "heartbeatPing" | "newDocument" | "newStructure" | "newUser" | "removedID" | "changedDocument" | "changedStructure" | "changedUser" | "confirmSubscription" | "confirmUnsubscription";
+export interface I_DocumentType {
+    _id?: string;
+    type: number;
+    subType: number;
+    name: string;
+    description?: string;
+    defaultStructureID?: string;
+}
+export type I_EventString = 'subscribe' | 'unsubscribe' | 'heartbeatPong' | "heartbeatPing" | "newDocument" | "newStructure" | "newUser" | "removedID" | "changedDocument" | "changedStructure" | "changedUser" | "confirmSubscription" | "confirmUnsubscription" | "removedUser" | "removedStructure" | "removedDocument";
 export interface I_WsMessage {
     newDocument?: I_DocumentEntry;
     newStructure?: I_StructureEntry;

package/dist/types.js

@@ -1,3 +1,2 @@
-"use strict";
 // Common type definitions for both frontend and backend
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};

package/package.json

@@ -1,8 +1,15 @@
 {
   "name": "docpouch-client",
-  "version": "0.8.3",
+  "version": "0.8.5",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.js"
+    }
+  },
+  "type": "module",
   "scripts": {
     "build": "tsc",
     "test": "jest"
@@ -15,13 +22,13 @@
   "license": "MIT",
   "description": "A small class to more easily access the docPouch API",
   "devDependencies": {
-    "@types/node": "^22.15.24",
-    "socket.io-client": "^4.8.1",
-    "jest": "^29.7.0",
-    "ts-jest": "^29.3.4",
-    "@types/jest": "^29.5.14"
+    "@types/jest": "^30.0.0",
+    "@types/node": "^24.0.3",
+    "jest": "^30.0.2",
+    "ts-jest": "^29.4.0"
   },
   "dependencies": {
+    "socket.io-client": "^4.8.1",
     "typescript": "^5.8.3"
   }
-}
+}

package/src/__tests__/index.test.ts

@@ -1,4 +1,4 @@
-import Index from '../index.js';
+import docPouchClient from '../index.js';
 import packetJson from '../../package.json';
 import {
   I_UserLogin,
@@ -28,7 +28,7 @@ global.fetch = jest.fn();
 const mockFetch = global.fetch as jest.Mock;
 
 describe('Index Class', () => {
-  let index: Index;
+  let index: docPouchClient;
   const baseUrl = 'http://example.com';
 
   beforeEach(() => {
@@ -37,7 +37,7 @@ describe('Index Class', () => {
     mockFetch.mockClear();
 
     // Create a new instance of Index for each test
-    index = new Index(baseUrl);
+    index = new docPouchClient(baseUrl);
 
     // Mock successful fetch response
     mockFetch.mockImplementation(() => 
@@ -62,7 +62,7 @@ describe('Index Class', () => {
 
     it('should connect socket and set up event handler when callback is provided', () => {
       const mockCallback = jest.fn();
-      const indexWithCallback = new Index(baseUrl, mockCallback);
+      const indexWithCallback = new docPouchClient(baseUrl, mockCallback);
 
       expect(indexWithCallback.socket.connect).toHaveBeenCalled();
       expect(indexWithCallback.socket.onAny).toHaveBeenCalled();
@@ -86,7 +86,7 @@ describe('Index Class', () => {
       jest.mock('../../package.json', () => ({ version: packetJson.version }), { virtual: true });
 
       // We need to re-create the index instance to pick up the mocked package.json
-      const newIndex = new Index(baseUrl);
+      const newIndex = new docPouchClient(baseUrl);
       expect(newIndex.getVersion()).toBe(packetJson.version);
     });
   });
@@ -472,7 +472,7 @@ describe('Index Class', () => {
   describe('WebSocket functionality', () => {
     it('should connect socket when callback is provided', () => {
       const mockCallback = jest.fn();
-      const indexWithCallback = new Index(baseUrl, mockCallback);
+      const indexWithCallback = new docPouchClient(baseUrl, mockCallback);
 
       // Verify that connect was called
       expect(indexWithCallback.socket.connect).toHaveBeenCalled();
@@ -480,7 +480,7 @@ describe('Index Class', () => {
 
     it('should set up event handler when callback is provided', () => {
       const mockCallback = jest.fn();
-      const indexWithCallback = new Index(baseUrl, mockCallback);
+      const indexWithCallback = new docPouchClient(baseUrl, mockCallback);
 
       // Verify that onAny was called
       expect(indexWithCallback.socket.onAny).toHaveBeenCalled();

package/src/index.ts

@@ -6,136 +6,392 @@ import type {
     I_UserDisplay,
     I_DocumentEntry,
     I_DataStructure,
-    I_LoginResponse, I_DocumentQuery, I_StructureCreation, I_WsMessage, I_EventString
+  I_LoginResponse, I_DocumentQuery, I_StructureCreation, I_WsMessage, I_EventString, I_DocumentType
 } from "./types.js";
 import {io, Socket} from "socket.io-client";
 import packetJson from '../package.json'
 
-export default class Index {
-    baseUrl: string;
-    private token: string | null = null;
-    socket: Socket
+/**
+ * Client for interacting with docPouch API.
+ */
+export default class docPouchClient {
+  /**
+   * The base URL of the server.
+   *
+   * @type {string}
+   */
+  baseUrl: string;
+  /**
+   * Socket.IO socket instance for real-time communication with the server.
+   *
+   * @type {Socket}
+   */
+  socket: Socket;
+  /**
+   * Callback function to handle socket events.
+   *
+   * @type {(event: I_EventString, data: I_WsMessage) => void}
+   */
+  callbackFunction;
+  /**
+   * Flag indicating whether real-time synchronization is enabled.
+   *
+   * @type {boolean}
+   */
+  realTimeSync: boolean = false;
+  /**
+   * Authentication token used to authorize requests.
+   *
+   * @private
+   * @type {string | null}
+   */
+  private authToken: string | null = null;
+  /**
+   * Flag indicating whether a connection attempt is in progress.
+   *
+   * @private
+   * @type {boolean}
+   */
+  private connectionInProgress = false;
 
-    constructor(baseUrl: string, callback?: (event: I_EventString, data: I_WsMessage) => void) {
-        this.baseUrl = baseUrl;
+  /**
+   * Creates an instance of docPouchClient.
+   *
+   * @param {string} host - The base URL for the server.
+   * @param {number} [port=80] - The port number to connect to (default is 80).
+   * @param {(event: I_EventString, data: I_WsMessage) => void} [callback] - Optional callback function for socket events.
+   */
+  constructor(host: string, port: number = 80, callback?: (event: I_EventString, data: I_WsMessage) => void) {
+    this.baseUrl = host;
+    const socketUrl = host.includes('://') ? host : `https://${host}`;
+    const socketUrlWithPort = socketUrl.includes(':') && !socketUrl.endsWith(':')
+        ? socketUrl
+        : `${socketUrl}:${port}`;
 
-        this.socket = io(baseUrl, { autoConnect: false });
-        if (callback) {
-            this.socket.connect();
-            this.socket.onAny((event: I_EventString, data: I_WsMessage) => {
-                if (event === "heartbeatPing") {
-                    console.log("Ping event received:", data);
-                    this.socket.emit("heartbeatPong", Date.now());
-                }
-                else {
-                    callback(event, data);
-                }
-            });
-        }
-    }
+    console.log(`Initializing Socket.IO with URL: ${socketUrlWithPort}, path: /socket.io`);
 
-    private async request<T>(endpoint: string, method: string, body?: any, requiresAuth: boolean = true): Promise<T> {
-        const headers: HeadersInit = {
-            'Content-Type': 'application/json'
-        };
+    this.socket = io(`${socketUrlWithPort}`, {
+      autoConnect: false,
+      transports: ['websocket'],  // Try websocket only first
+      reconnection: true,
+      reconnectionAttempts: 5,
+      reconnectionDelay: 1000,
+      forceNew: true,  // Force a new connection
+      auth: {
+        token: null  // Will be set later
+      },
+      path: '/socket.io'
+    });
 
-        if (requiresAuth && this.token) {
-            headers['Authorization'] = `Bearer ${this.token}`;
-        }
+    this.callbackFunction = callback;
 
-        const options: RequestInit = {
-            method,
-            headers,
-            body: body ? JSON.stringify(body) : undefined
-        };
+    this.setupPermanentSocketListeners();
+  }
 
-        const response = await fetch(`${this.baseUrl}${endpoint}`, options);
+  /**
+   * Sets the real-time synchronization status.
+   *
+   * @param {boolean} newRealTimeSync - The new real-time sync setting (true/false).
+   */
+  setRealTimeSync(newRealTimeSync: boolean) {
+    console.log(`Setting realtime sync to: ${newRealTimeSync}. Current setting: ${this.realTimeSync}`);
 
-        if (!response.ok) {
-            if (response.status === 401 || response.status === 403) {
-                this.token = null;
-            }
-            throw new Error(`API error: ${response.status} ${response.statusText}`);
-        }
-
-        return await response.json() as T;
+    // Skip if the setting isn't changing
+    if (newRealTimeSync === this.realTimeSync) {
+      console.log("Realtime sync setting unchanged, skipping");
+      return;
     }
 
-    // User Administration Endpoints
-    async login(credentials: I_UserLogin): Promise<I_LoginResponse | null> {
-        const response = await this.request<I_LoginResponse>('/users/login', 'POST', credentials, false);
-        if (response.token) {
-            this.token = response.token;
-            return {token: response.token, isAdmin: response.isAdmin};
-        }
-        return null;
-    }
+    this.realTimeSync = newRealTimeSync;
 
-    async listUsers(): Promise<I_UserEntry[]> {
-        return await this.request<I_UserEntry[]>('/users/list', 'GET');
-    }
+    if (newRealTimeSync && this.authToken) {
+      console.log("Activating realtime updates");
 
-    async updateUser(userID: string, userData: I_UserUpdate): Promise<void> {
-        await this.request<void>(`/users/update/${userID}`, 'PATCH', userData);
+      // Ensure we're not in the middle of another connection attempt
+      if (this.connectionInProgress) {
+        console.log("Connection already in progress, waiting before initializing");
+        setTimeout(() => this.initWebSocket(), 500);
+      } else {
+        this.initWebSocket();
+      }
+    } else if (!newRealTimeSync) {
+      console.log("Deactivating realtime updates");
+      if (this.socket.connected) {
+        console.log("Disconnecting socket");
+        this.socket.disconnect();
+      }
     }
+  }
 
-    async createUser(userData: I_UserCreation): Promise<I_UserDisplay> {
-        return await this.request<I_UserDisplay>('/users/create', 'POST', userData);
-    }
+  // User Administration Endpoints
+  async login(credentials: I_UserLogin): Promise<I_LoginResponse | null> {
+    const response = await this.request<I_LoginResponse>('/users/login', 'POST', credentials, false);
+    if (response.token) {
+      this.authToken = response.token;
 
-    async removeUser(userID: string): Promise<void> {
-        await this.request<void>(`/users/remove/${userID}`, 'DELETE');
-    }
+      // Reconnect websocket with new token if realtime sync is enabled
+      if (this.realTimeSync) {
+        this.initWebSocket();
+      }
 
-    // Document Management Endpoints
-    async createDocument(document: I_DocumentEntry): Promise<I_DocumentEntry> {
-        return await this.request<I_DocumentEntry>('/docs/create', 'POST', document);
+      return {token: response.token, isAdmin: response.isAdmin};
     }
+    return null;
+  }
 
-    async listDocuments(): Promise<I_DocumentEntry[]> {
-        return await this.request<I_DocumentEntry[]>('/docs/list', 'GET');
-    }
+  async listUsers(): Promise<I_UserEntry[]> {
+    return await this.request<I_UserEntry[]>('/users/list', 'GET');
+  }
 
-    async fetchDocument(queryObject: I_DocumentQuery): Promise<I_DocumentEntry[]> {
-        return await this.request<I_DocumentEntry[]>(`/docs/fetch/`, 'POST', queryObject);
-    }
+  async updateUser(userID: string, userData: I_UserUpdate): Promise<void> {
+    await this.request<void>(`/users/update/${userID}`, 'PATCH', userData);
+  }
 
-    async updateDocument(documentID: string, documentData: I_DocumentEntry): Promise<void> {
-        await this.request<void>(`/docs/update/${documentID}`, 'PATCH', documentData);
-    }
+  async createUser(userData: I_UserCreation): Promise<I_UserDisplay> {
+    return await this.request<I_UserDisplay>('/users/create', 'POST', userData);
+  }
+
+  async removeUser(userID: string): Promise<void> {
+    await this.request<void>(`/users/remove/${userID}`, 'DELETE');
+  }
+
+  // Document Management Endpoints
+  async createDocument(document: I_DocumentEntry): Promise<I_DocumentEntry> {
+    return await this.request<I_DocumentEntry>('/docs/create', 'POST', document);
+  }
+
+  async listDocuments(): Promise<I_DocumentEntry[]> {
+    return await this.request<I_DocumentEntry[]>('/docs/list', 'GET');
+  }
+
+  async fetchDocument(queryObject: I_DocumentQuery): Promise<I_DocumentEntry[]> {
+    return await this.request<I_DocumentEntry[]>(`/docs/fetch/`, 'POST', queryObject);
+  }
+
+  async updateDocument(documentID: string, documentData: I_DocumentEntry): Promise<void> {
+    await this.request<void>(`/docs/update/${documentID}`, 'PATCH', documentData);
+  }
+
+  async removeDocument(documentID: string): Promise<void> {
+    await this.request<void>(`/docs/remove/${documentID}`, 'DELETE');
+  }
+
+  // Data Structure Endpoints
+  async createStructure(structure: I_StructureCreation): Promise<I_DataStructure> {
+    return await this.request<I_DataStructure>('/structures/create', 'POST', structure);
+  }
+
+  async getStructures(): Promise<I_DataStructure[]> {
+    return await this.request<I_DataStructure[]>('/structures/list', 'GET');
+  }
+
+  async updateStructure(structureID: string, structureData: I_DataStructure): Promise<void> {
+    await this.request<void>(`/structures/update/${structureID}`, 'PATCH', structureData);
+  }
+
+  async removeStructure(structureID: string): Promise<void> {
+    await this.request<void>(`/structures/remove/${structureID}`, 'DELETE');
+  }
+
+  // Data Type Endpoints
+  async createType(type: I_DocumentType): Promise<I_DocumentType> {
+    return await this.request<I_DocumentType>('/types/write', 'PATCH', type);
+  }
+
+  async removeType(typeID: string) {
+    return await this.request<void>(`/types/remove/${typeID}`, 'DELETE');
+  }
+
+  async getTypes(): Promise<I_DocumentType[]> {
+    return await this.request<I_DocumentType[]>('/types/list', 'GET');
+  }
+
+  async updateType(updatedType: I_DocumentType): Promise<void> {
+    await this.request<void>(`/types/write`, 'PATCH', updatedType);
+  }
 
-    async removeDocument(documentID: string): Promise<void> {
-        await this.request<void>(`/docs/remove/${documentID}`, 'DELETE');
+  setToken(token: string | null): void {
+    console.log("Setting token to:", token ? "***token***" : "null");
+
+    const tokenChanged = this.authToken !== token;
+    this.authToken = token;
+
+    if (!tokenChanged) {
+      console.log("Token unchanged, no need to reconnect");
+      return;
     }
 
-    // Data Structure Endpoints
-    async createStructure(structure: I_StructureCreation): Promise<I_DataStructure> {
-        return await this.request<I_DataStructure>('/structures/create', 'POST', structure);
+    // If we have a new token and realtime sync is enabled
+    if (token && this.realTimeSync) {
+      console.log("New token set, will initialize WebSocket");
+
+      // Ensure any existing connection is closed first
+      if (this.socket.connected) {
+        console.log("Disconnecting existing socket before reconnecting with new token");
+        this.socket.disconnect();
+      }
+
+      // Wait a moment for the disconnect to complete
+      setTimeout(() => {
+        console.log("Initializing WebSocket with new token");
+        this.initWebSocket();
+      }, 300);
     }
+    // If token was cleared or realtime sync is disabled
+    else if (this.socket.connected) {
+      console.log("Token cleared or realtime sync disabled, disconnecting");
+      this.socket.disconnect();
+    }
+  }
+
+  getVersion() {
+    return packetJson.version;
+  }
+
+  debugSocketConnection(): void {
+    console.log("Socket connection debug info:");
+    console.log("- Connected:", this.socket.connected);
+    console.log("- Socket ID:", this.socket.id);
+    console.log("- Auth token present:", !!this.authToken);
+    console.log("- Connection in progress:", this.connectionInProgress);
+    console.log("- Realtime sync enabled:", this.realTimeSync);
+    console.log("- Socket options:", this.socket.io.opts);
 
-    async getStructures(): Promise<I_DataStructure[]> {
-        return await this.request<I_DataStructure[]>('/structures/list', 'GET');
+    // Try to force reconnection
+    if (!this.socket.connected && this.authToken && this.realTimeSync) {
+      console.log("Attempting to force reconnection...");
+      this.socket.auth = {token: this.authToken};
+      this.socket.connect();
     }
+  }
 
-    async updateStructure(structureID: string, structureData: I_DataStructure): Promise<void> {
-        await this.request<void>(`/structures/update/${structureID}`, 'PATCH', structureData);
+  /**
+   * Sets up permanent socket listeners for the client.
+   *
+   * @private
+   */
+  private setupPermanentSocketListeners() {
+    // These are permanent listeners that won't be removed
+    this.socket.on('connect_error', (error) => {
+      console.error('Socket connection error:', error.message);
+      this.connectionInProgress = false;
+    });
+
+    this.socket.on('connect', () => {
+      console.log('Socket connected successfully with ID:', this.socket.id);
+      this.connectionInProgress = false;
+    });
+
+    this.socket.on('disconnect', (reason) => {
+      console.log('Socket disconnected. Reason:', reason);
+      this.connectionInProgress = false;
+    });
+
+    this.socket.on('error', (error) => {
+      console.error('Socket error:', error);
+      this.connectionInProgress = false;
+    });
+  }
+
+  /**
+   * Initializes the WebSocket connection with the server.
+   *
+   * @private
+   */
+  private initWebSocket() {
+    console.log("initWebSocket called. Auth token present:", !!this.authToken,
+        "Connection in progress:", this.connectionInProgress,
+        "Socket connected:", this.socket.connected);
+
+    if (!this.authToken) {
+      console.log("Skipping WebSocket initialization: No auth token");
+      return;
     }
 
-    async removeStructure(structureID: string): Promise<void> {
-        await this.request<void>(`/structures/remove/${structureID}`, 'DELETE');
+    if (this.connectionInProgress) {
+      console.log("Connection already in progress, skipping initialization");
+      return;
     }
 
-    setToken(token: string | null): void {
-        this.token = token;
+    if (this.socket.connected) {
+      console.log("Socket already connected with ID:", this.socket.id);
+      return;
     }
 
-    getToken() {
-        return this.token;
+    this.connectionInProgress = true;
+
+    try {
+      console.log("Setting up WebSocket connection with token");
+
+      // Update the auth token
+      this.socket.auth = {token: this.authToken};
+
+      // Remove any dynamic event listeners that might have been added
+      this.socket.offAny();
+
+      // Set up event handler for application events
+      this.socket.onAny((event: I_EventString, data: I_WsMessage) => {
+        if (event === "heartbeatPing") {
+          console.log("Ping event received:", data);
+          this.socket.emit("heartbeatPong", Date.now());
+        } else if (this.callbackFunction) {
+          this.callbackFunction(event, data);
+        }
+      });
+
+      // Connect to the server
+      console.log("Connecting socket with auth token");
+      this.socket.connect();
+
+      // Add a timeout to detect if connection is taking too long
+      setTimeout(() => {
+        if (this.connectionInProgress) {
+          console.warn("Socket connection attempt timed out after 5 seconds");
+          this.connectionInProgress = false;
+
+          // If we're still not connected after the timeout, try again with polling
+          if (!this.socket.connected) {
+            console.log("Retrying connection with polling transport");
+            this.socket.io.opts.transports = ['polling', 'websocket'];
+            this.socket.connect();
+          }
+        }
+      }, 5000);
+    } catch (error) {
+      console.error('Error in initWebSocket:', error);
+      this.connectionInProgress = false;
     }
+  }
+
+  private async request<T>(endpoint: string, method: string, body?: any, requiresAuth: boolean = true): Promise<T> {
+    const headers: HeadersInit = {
+      'Content-Type': 'application/json',
+    };
+
+    if (requiresAuth && this.authToken)
+      headers['Authorization'] = `Bearer ${this.authToken}`;
+    if (this.socket.id)
+      headers['X-Socket-ID'] = this.socket.id;
 
-    getVersion() {
-        return packetJson.version;
+    const options: RequestInit = {
+      method,
+      headers,
+      body: body ? JSON.stringify(body) : undefined
+    };
+
+    const normalizedEndpoint = endpoint.startsWith('/') ? endpoint : `/${endpoint}`;
+    const normalizedBaseUrl = this.baseUrl.endsWith('/') ? this.baseUrl.slice(0, -1) : this.baseUrl;
+    const url = `${normalizedBaseUrl}${normalizedEndpoint}`;
+    const response = await fetch(url, options);
+
+    if (!response.ok) {
+      if (response.status === 401 || response.status === 403) {
+        this.authToken = null;
+      }
+      throw new Error(`API error: ${response.status} ${response.statusText}`);
     }
-}
 
-module.exports = Index;
+    return await response.json() as T;
+  }
+
+}

package/src/types.ts

@@ -104,10 +104,20 @@ export interface I_StructureUpdate {
     fields?: any[];
 }
 
+// Document type related types
+export interface I_DocumentType {
+    _id?: string;
+    type: number;
+    subType: number;
+    name: string;
+    description?: string;
+    defaultStructureID?: string;
+}
+
 // WebSocket-related types
 export type I_EventString = 'subscribe' | 'unsubscribe' | 'heartbeatPong' | "heartbeatPing" | "newDocument" | "newStructure" |
     "newUser" | "removedID" | "changedDocument" | "changedStructure" | "changedUser" | "confirmSubscription" |
-    "confirmUnsubscription";
+    "confirmUnsubscription" | "removedUser" | "removedStructure" | "removedDocument";
 
 export interface I_WsMessage {
     newDocument?: I_DocumentEntry;

package/tsconfig.json

@@ -13,7 +13,8 @@
     "declaration": true,
     "emitDeclarationOnly": false,
     "resolveJsonModule": true,
-    "isolatedModules": true
+    "isolatedModules": true,
+    "allowSyntheticDefaultImports": true
   },
   "include": ["**/*.ts", "**/*.tsx"],
   "exclude": ["node_modules", "**/*.test.ts", "**/*.types.ts", "./dist/**/*"]