docpouch-client 0.8.8 → 0.8.9

package/dist/index.d.ts

@@ -0,0 +1,208 @@
+import { Socket } from "socket.io-client";
+/**
+ * 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: ((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>;
+    createUser(userData: I_UserCreation): Promise<I_UserDisplay>;
+    removeUser(userID: string): Promise<void>;
+    createDocument(document: I_DocumentEntry): Promise<I_DocumentEntry>;
+    listDocuments(): Promise<I_DocumentEntry[]>;
+    fetchDocument(queryObject: I_DocumentQuery): Promise<I_DocumentEntry[]>;
+    updateDocument(documentID: string, documentData: I_DocumentEntry): Promise<void>;
+    removeDocument(documentID: string): Promise<void>;
+    createStructure(structure: I_StructureCreation): Promise<I_DataStructure>;
+    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;
+    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;
+}
+export interface I_UserEntry extends I_UserCreation {
+    _id: string;
+}
+export interface I_UserLogin {
+    name: string;
+    password: string;
+}
+export interface I_UserCreation {
+    name: string;
+    password: string;
+    email?: string;
+    department: string;
+    group: string;
+    isAdmin: boolean;
+}
+export interface I_UserUpdate {
+    _id: string;
+    name?: string;
+    password?: string;
+    email?: string;
+    department?: string;
+    group?: string;
+    isAdmin?: boolean;
+}
+export interface I_UserDisplay {
+    _id: string;
+    username: string;
+    department: string;
+    group: string;
+    email?: string;
+}
+export interface I_LoginResponse {
+    token: string;
+    isAdmin: boolean;
+    userName: string;
+}
+export interface I_DocumentEntry extends I_DocumentCreationOwned {
+    _id: string;
+}
+export interface I_DocumentCreation {
+    title: string;
+    description?: string;
+    type: number;
+    subType: number;
+    content: any;
+    shareWithGroup: boolean;
+    shareWithDepartment: boolean;
+}
+export interface I_DocumentCreationOwned extends I_DocumentCreation {
+    owner: string;
+}
+export interface I_DocumentUpdate extends I_DocumentQuery {
+    _id: string;
+    content?: any;
+    description?: string;
+}
+export interface I_DocumentQuery {
+    _id?: string;
+    owner?: string;
+    title?: string;
+    type?: number;
+    subType?: number;
+    shareWithGroup?: boolean;
+    shareWithDepartment?: boolean;
+}
+export interface I_DataStructure {
+    _id?: string | undefined;
+    name: string;
+    description: string;
+    fields: I_StructureField[];
+}
+export interface I_StructureField {
+    name: string;
+    type: string;
+    items?: string;
+}
+export interface I_StructureEntry {
+    _id?: string;
+    name: string;
+    description: string;
+    fields: I_StructureField[];
+}
+export interface I_StructureCreation {
+    name: string;
+    description?: string;
+    fields: I_StructureField[];
+}
+export interface I_StructureUpdate {
+    _id?: string;
+    name?: string;
+    description?: string;
+    fields?: I_StructureField[];
+}
+export interface I_DocumentType {
+    _id?: string;
+    type: number;
+    subType: number;
+    name: string;
+    description?: string;
+    defaultStructureID?: string;
+}
+export type I_EventString = 'heartbeatPong' | "heartbeatPing" | "newDocument" | "newStructure" | "newUser" | "newType" | "removedID" | "changedDocument" | "changedStructure" | "changedUser" | "changedType" | "removedUser" | "removedStructure" | "removedDocument" | "removedType";
+export interface I_WsMessage {
+    newDocument?: I_DocumentEntry;
+    newStructure?: I_StructureEntry;
+    newUser?: I_UserEntry;
+    removedID?: string;
+    changedDocument?: I_DocumentUpdate;
+    changedStructure?: I_StructureUpdate;
+    changedUser?: I_UserUpdate;
+    confirmSubscription?: boolean;
+    confirmUnsubscription?: boolean;
+    heartbeatPing?: number;
+    heartbeatPong?: number;
+    newType?: I_DocumentType;
+}

package/dist/index.js

@@ -0,0 +1,308 @@
+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();
+    }
+    /**
+     * 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;
+        }
+        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();
+            }
+        }
+    }
+    // User Administration Endpoints
+    async login(credentials) {
+        const response = await this.request('/users/login', 'POST', credentials, false);
+        if (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, userName: response.userName };
+        }
+        return null;
+    }
+    async listUsers() {
+        return await this.request('/users/list', 'GET');
+    }
+    async updateUser(userID, userData) {
+        await this.request(`/users/update/${userID}`, 'PATCH', userData);
+    }
+    async createUser(userData) {
+        return await this.request('/users/create', 'POST', userData);
+    }
+    async removeUser(userID) {
+        await this.request(`/users/remove/${userID}`, 'DELETE');
+    }
+    // Document Management Endpoints
+    async createDocument(document) {
+        return await this.request('/docs/create', 'POST', document);
+    }
+    async listDocuments() {
+        return await this.request('/docs/list', 'GET');
+    }
+    async fetchDocument(queryObject) {
+        return await this.request(`/docs/fetch/`, 'POST', queryObject);
+    }
+    async updateDocument(documentID, documentData) {
+        await this.request(`/docs/update/${documentID}`, 'PATCH', documentData);
+    }
+    async removeDocument(documentID) {
+        await this.request(`/docs/remove/${documentID}`, 'DELETE');
+    }
+    // Data Structure Endpoints
+    async createStructure(structure) {
+        return await this.request('/structures/create', 'POST', structure);
+    }
+    async getStructures() {
+        return await this.request('/structures/list', 'GET');
+    }
+    async updateStructure(structureID, structureData) {
+        await this.request(`/structures/update/${structureID}`, 'PATCH', structureData);
+    }
+    async removeStructure(structureID) {
+        await this.request(`/structures/remove/${structureID}`, 'DELETE');
+    }
+    // Data Type Endpoints
+    async createType(type) {
+        return await this.request('/types/write', 'POST', type);
+    }
+    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`, 'POST', 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 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();
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "docpouch-client",
-  "version": "0.8.8",
+  "version": "0.8.9",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {

package/src/__tests__/index.test.ts

@@ -1,489 +0,0 @@
-import docPouchClient from '../index.js';
-import packetJson from '../../package.json';
-import {
-  I_UserLogin,
-  I_UserCreation,
-  I_UserUpdate,
-  I_DocumentEntry,
-  I_DocumentQuery,
-  I_StructureCreation,
-  I_DataStructure,
-} from '../types.js';
-
-// Mock socket.io-client
-jest.mock('socket.io-client', () => {
-  const mockSocket = {
-    connect: jest.fn(),
-    emit: jest.fn(),
-    onAny: jest.fn(),
-  };
-  return {
-    io: jest.fn(() => mockSocket),
-    Socket: jest.requireActual('socket.io-client').Socket,
-  };
-});
-
-// Mock fetch API
-global.fetch = jest.fn();
-const mockFetch = global.fetch as jest.Mock;
-
-describe('Index Class', () => {
-  let index: docPouchClient;
-  const baseUrl = 'http://example.com';
-
-  beforeEach(() => {
-    // Reset mocks before each test
-    jest.clearAllMocks();
-    mockFetch.mockClear();
-
-    // Create a new instance of Index for each test
-    index = new docPouchClient(baseUrl);
-
-    // Mock successful fetch response
-    mockFetch.mockImplementation(() => 
-      Promise.resolve({
-        ok: true,
-        status: 200,
-        statusText: 'OK',
-        json: () => Promise.resolve({}),
-      })
-    );
-  });
-
-  // Test constructor
-  describe('constructor', () => {
-    it('should initialize with the provided baseUrl', () => {
-      expect(index.baseUrl).toBe(baseUrl);
-    });
-
-    it('should initialize socket with autoConnect: false by default', () => {
-      expect(require('socket.io-client').io).toHaveBeenCalledWith(baseUrl, { autoConnect: false });
-    });
-
-    it('should connect socket and set up event handler when callback is provided', () => {
-      const mockCallback = jest.fn();
-      const indexWithCallback = new docPouchClient(baseUrl, mockCallback);
-
-      expect(indexWithCallback.socket.connect).toHaveBeenCalled();
-      expect(indexWithCallback.socket.onAny).toHaveBeenCalled();
-    });
-  });
-
-  // Test utility methods
-  describe('utility methods', () => {
-    it('should set and get token correctly', () => {
-      const token = 'test-token';
-      index.setToken(token);
-      expect(index.getToken()).toBe(token);
-    });
-
-    it('should return null when token is not set', () => {
-      expect(index.getToken()).toBeNull();
-    });
-
-    it('should return the correct version', () => {
-      // Mock package.json
-      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 docPouchClient(baseUrl);
-      expect(newIndex.getVersion()).toBe(packetJson.version);
-    });
-  });
-
-  // Test user administration endpoints
-  describe('user administration endpoints', () => {
-    it('should login successfully and store token', async () => {
-      const credentials: I_UserLogin = { name: 'testuser', password: 'password' };
-      const mockResponse = { token: 'test-token', isAdmin: true };
-
-      mockFetch.mockImplementationOnce(() => 
-        Promise.resolve({
-          ok: true,
-          status: 200,
-          statusText: 'OK',
-          json: () => Promise.resolve(mockResponse),
-        })
-      );
-
-      const result = await index.login(credentials);
-
-      expect(mockFetch).toHaveBeenCalledWith(
-        `${baseUrl}/users/login`,
-        expect.objectContaining({
-          method: 'POST',
-          body: JSON.stringify(credentials),
-        })
-      );
-      expect(result).toEqual(mockResponse);
-      expect(index.getToken()).toBe('test-token');
-    });
-
-    it('should return null when login fails', async () => {
-      const credentials: I_UserLogin = { name: 'testuser', password: 'wrong-password' };
-
-      mockFetch.mockImplementationOnce(() => 
-        Promise.resolve({
-          ok: true,
-          status: 200,
-          statusText: 'OK',
-          json: () => Promise.resolve({}),
-        })
-      );
-
-      const result = await index.login(credentials);
-
-      expect(result).toBeNull();
-    });
-
-    it('should list users', async () => {
-      const mockUsers = [{ _id: '1', name: 'user1', password: 'pass1', department: 'dept1', group: 'group1', isAdmin: false }];
-
-      mockFetch.mockImplementationOnce(() => 
-        Promise.resolve({
-          ok: true,
-          status: 200,
-          statusText: 'OK',
-          json: () => Promise.resolve(mockUsers),
-        })
-      );
-
-      const result = await index.listUsers();
-
-      expect(mockFetch).toHaveBeenCalledWith(
-        `${baseUrl}/users/list`,
-        expect.objectContaining({
-          method: 'GET',
-        })
-      );
-      expect(result).toEqual(mockUsers);
-    });
-
-    it('should update a user', async () => {
-      const userId = '1';
-      const userData: I_UserUpdate = { name: 'updated-user', department: 'new-dept' };
-
-      await index.updateUser(userId, userData);
-
-      expect(mockFetch).toHaveBeenCalledWith(
-        `${baseUrl}/users/update/${userId}`,
-        expect.objectContaining({
-          method: 'PATCH',
-          body: JSON.stringify(userData),
-        })
-      );
-    });
-
-    it('should create a user', async () => {
-      const userData: I_UserCreation = {
-        name: 'newuser',
-        password: 'password',
-        department: 'dept',
-        group: 'group',
-        isAdmin: false
-      };
-      const mockResponse = { _id: '2', username: 'newuser', department: 'dept', group: 'group' };
-
-      mockFetch.mockImplementationOnce(() => 
-        Promise.resolve({
-          ok: true,
-          status: 200,
-          statusText: 'OK',
-          json: () => Promise.resolve(mockResponse),
-        })
-      );
-
-      const result = await index.createUser(userData);
-
-      expect(mockFetch).toHaveBeenCalledWith(
-        `${baseUrl}/users/create`,
-        expect.objectContaining({
-          method: 'POST',
-          body: JSON.stringify(userData),
-        })
-      );
-      expect(result).toEqual(mockResponse);
-    });
-
-    it('should remove a user', async () => {
-      const userId = '1';
-
-      await index.removeUser(userId);
-
-      expect(mockFetch).toHaveBeenCalledWith(
-        `${baseUrl}/users/remove/${userId}`,
-        expect.objectContaining({
-          method: 'DELETE',
-        })
-      );
-    });
-  });
-
-  // Test document management endpoints
-  describe('document management endpoints', () => {
-    it('should create a document', async () => {
-      const document: I_DocumentEntry = {
-        _id: '1',
-        title: 'Test Document',
-        type: 1,
-        subType: 2,
-        content: { data: 'test content' },
-        owner: 'user1'
-      };
-
-      mockFetch.mockImplementationOnce(() => 
-        Promise.resolve({
-          ok: true,
-          status: 200,
-          statusText: 'OK',
-          json: () => Promise.resolve(document),
-        })
-      );
-
-      const result = await index.createDocument(document);
-
-      expect(mockFetch).toHaveBeenCalledWith(
-        `${baseUrl}/docs/create`,
-        expect.objectContaining({
-          method: 'POST',
-          body: JSON.stringify(document),
-        })
-      );
-      expect(result).toEqual(document);
-    });
-
-    it('should list documents', async () => {
-      const mockDocuments = [
-        { _id: '1', title: 'Doc1', type: 1, subType: 1, content: {}, owner: 'user1' },
-        { _id: '2', title: 'Doc2', type: 2, subType: 2, content: {}, owner: 'user2' }
-      ];
-
-      mockFetch.mockImplementationOnce(() => 
-        Promise.resolve({
-          ok: true,
-          status: 200,
-          statusText: 'OK',
-          json: () => Promise.resolve(mockDocuments),
-        })
-      );
-
-      const result = await index.listDocuments();
-
-      expect(mockFetch).toHaveBeenCalledWith(
-        `${baseUrl}/docs/list`,
-        expect.objectContaining({
-          method: 'GET',
-        })
-      );
-      expect(result).toEqual(mockDocuments);
-    });
-
-    it('should fetch documents based on query', async () => {
-      const query: I_DocumentQuery = { type: 1, owner: 'user1' };
-      const mockDocuments = [
-        { _id: '1', title: 'Doc1', type: 1, subType: 1, content: {}, owner: 'user1' }
-      ];
-
-      mockFetch.mockImplementationOnce(() => 
-        Promise.resolve({
-          ok: true,
-          status: 200,
-          statusText: 'OK',
-          json: () => Promise.resolve(mockDocuments),
-        })
-      );
-
-      const result = await index.fetchDocument(query);
-
-      expect(mockFetch).toHaveBeenCalledWith(
-        `${baseUrl}/docs/fetch/`,
-        expect.objectContaining({
-          method: 'POST',
-          body: JSON.stringify(query),
-        })
-      );
-      expect(result).toEqual(mockDocuments);
-    });
-
-    it('should update a document', async () => {
-      const documentId = '1';
-      const documentData: I_DocumentEntry = {
-        _id: '1',
-        title: 'Updated Document',
-        type: 1,
-        subType: 2,
-        content: { data: 'updated content' },
-        owner: 'user1'
-      };
-
-      await index.updateDocument(documentId, documentData);
-
-      expect(mockFetch).toHaveBeenCalledWith(
-        `${baseUrl}/docs/update/${documentId}`,
-        expect.objectContaining({
-          method: 'PATCH',
-          body: JSON.stringify(documentData),
-        })
-      );
-    });
-
-    it('should remove a document', async () => {
-      const documentId = '1';
-
-      await index.removeDocument(documentId);
-
-      expect(mockFetch).toHaveBeenCalledWith(
-        `${baseUrl}/docs/remove/${documentId}`,
-        expect.objectContaining({
-          method: 'DELETE',
-        })
-      );
-    });
-  });
-
-  // Test data structure endpoints
-  describe('data structure endpoints', () => {
-    it('should create a structure', async () => {
-      const structure: I_StructureCreation = {
-        name: 'Test Structure',
-        description: 'Test Description',
-        fields: [{ name: 'field1', type: 'string' }]
-      };
-      const mockResponse: I_DataStructure = {
-        _id: '1',
-        name: 'Test Structure',
-        description: 'Test Description',
-        fields: [{ name: 'field1', type: 'string' }]
-      };
-
-      mockFetch.mockImplementationOnce(() => 
-        Promise.resolve({
-          ok: true,
-          status: 200,
-          statusText: 'OK',
-          json: () => Promise.resolve(mockResponse),
-        })
-      );
-
-      const result = await index.createStructure(structure);
-
-      expect(mockFetch).toHaveBeenCalledWith(
-        `${baseUrl}/structures/create`,
-        expect.objectContaining({
-          method: 'POST',
-          body: JSON.stringify(structure),
-        })
-      );
-      expect(result).toEqual(mockResponse);
-    });
-
-    it('should get structures', async () => {
-      const mockStructures = [
-        { _id: '1', name: 'Structure1', description: 'Desc1', fields: [] },
-        { _id: '2', name: 'Structure2', description: 'Desc2', fields: [] }
-      ];
-
-      mockFetch.mockImplementationOnce(() => 
-        Promise.resolve({
-          ok: true,
-          status: 200,
-          statusText: 'OK',
-          json: () => Promise.resolve(mockStructures),
-        })
-      );
-
-      const result = await index.getStructures();
-
-      expect(mockFetch).toHaveBeenCalledWith(
-        `${baseUrl}/structures/list`,
-        expect.objectContaining({
-          method: 'GET',
-        })
-      );
-      expect(result).toEqual(mockStructures);
-    });
-
-    it('should update a structure', async () => {
-      const structureId = '1';
-      const structureData: I_DataStructure = {
-        name: 'Updated Structure',
-        description: 'Updated Description',
-        fields: [{ name: 'updatedField', type: 'number' }]
-      };
-
-      await index.updateStructure(structureId, structureData);
-
-      expect(mockFetch).toHaveBeenCalledWith(
-        `${baseUrl}/structures/update/${structureId}`,
-        expect.objectContaining({
-          method: 'PATCH',
-          body: JSON.stringify(structureData),
-        })
-      );
-    });
-
-    it('should remove a structure', async () => {
-      const structureId = '1';
-
-      await index.removeStructure(structureId);
-
-      expect(mockFetch).toHaveBeenCalledWith(
-        `${baseUrl}/structures/remove/${structureId}`,
-        expect.objectContaining({
-          method: 'DELETE',
-        })
-      );
-    });
-  });
-
-  // Test error handling
-  describe('error handling', () => {
-    it('should throw an error when API request fails', async () => {
-      mockFetch.mockImplementationOnce(() => 
-        Promise.resolve({
-          ok: false,
-          status: 500,
-          statusText: 'Internal Server Error',
-        })
-      );
-
-      await expect(index.listUsers()).rejects.toThrow('API error: 500 Internal Server Error');
-    });
-
-    it('should clear token when receiving 401 or 403 status', async () => {
-      // Set a token first
-      index.setToken('test-token');
-
-      // Mock 401 response
-      mockFetch.mockImplementationOnce(() => 
-        Promise.resolve({
-          ok: false,
-          status: 401,
-          statusText: 'Unauthorized',
-        })
-      );
-
-      await expect(index.listUsers()).rejects.toThrow('API error: 401 Unauthorized');
-      expect(index.getToken()).toBeNull();
-    });
-  });
-
-  // Test WebSocket functionality
-  describe('WebSocket functionality', () => {
-    it('should connect socket when callback is provided', () => {
-      const mockCallback = jest.fn();
-      const indexWithCallback = new docPouchClient(baseUrl, mockCallback);
-
-      // Verify that connect was called
-      expect(indexWithCallback.socket.connect).toHaveBeenCalled();
-    });
-
-    it('should set up event handler when callback is provided', () => {
-      const mockCallback = jest.fn();
-      const indexWithCallback = new docPouchClient(baseUrl, mockCallback);
-
-      // Verify that onAny was called
-      expect(indexWithCallback.socket.onAny).toHaveBeenCalled();
-    });
-  });
-});