docpouch-client 0.8.2 → 0.8.3

package/dist/index.d.ts

@@ -1,10 +1,10 @@
-import type { I_UserEntry, I_UserLogin, I_UserCreation, I_UserUpdate, I_UserDisplay, I_DocumentEntry, I_DataStructure, I_LoginResponse, I_DocumentQuery, I_StructureCreation, I_WsMessage } from "./types.js";
-import { Manager } from "socket.io-client";
+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 { Socket } from "socket.io-client";
 export default class Index {
     baseUrl: string;
     private token;
-    socketManager: Manager<import("@socket.io/component-emitter").DefaultEventsMap, import("@socket.io/component-emitter").DefaultEventsMap>;
-    constructor(baseUrl: string, callback?: (event: string, data: I_WsMessage) => void);
+    socket: Socket;
+    constructor(baseUrl: string, callback?: (event: I_EventString, data: I_WsMessage) => void);
     private request;
     login(credentials: I_UserLogin): Promise<I_LoginResponse | null>;
     listUsers(): Promise<I_UserEntry[]>;
@@ -22,4 +22,5 @@ export default class Index {
     removeStructure(structureID: string): Promise<void>;
     setToken(token: string | null): void;
     getToken(): string | null;
+    getVersion(): string;
 }

package/dist/index.js

@@ -1,14 +1,26 @@
 "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.socketManager = new socket_io_client_1.Manager(baseUrl, { autoConnect: false });
+        this.socket = (0, socket_io_client_1.io)(baseUrl, { autoConnect: false });
         if (callback) {
-            this.socketManager.connect();
-            this.socketManager.onAny((event, data) => callback(event, data));
+            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);
+                }
+            });
         }
     }
     async request(endpoint, method, body, requiresAuth = true) {
@@ -61,7 +73,7 @@ class Index {
         return await this.request('/docs/list', 'GET');
     }
     async fetchDocument(queryObject) {
-        return await this.request(`/docs/fetch/`, 'GET');
+        return await this.request(`/docs/fetch/`, 'POST', queryObject);
     }
     async updateDocument(documentID, documentData) {
         await this.request(`/docs/update/${documentID}`, 'PATCH', documentData);
@@ -88,6 +100,9 @@ class Index {
     getToken() {
         return this.token;
     }
+    getVersion() {
+        return package_json_1.default.version;
+    }
 }
 exports.default = Index;
 module.exports = Index;

package/dist/types.d.ts

@@ -9,17 +9,23 @@ export interface I_UserCreation {
     name: string;
     password: string;
     email?: string;
+    department: string;
+    group: string;
     isAdmin: boolean;
 }
 export interface I_UserUpdate {
     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 {
@@ -78,6 +84,7 @@ 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_WsMessage {
     newDocument?: I_DocumentEntry;
     newStructure?: I_StructureEntry;
@@ -88,6 +95,6 @@ export interface I_WsMessage {
     changedUser?: I_UserUpdate;
     confirmSubscription?: boolean;
     confirmUnsubscription?: boolean;
-    ping?: number;
-    pong?: number;
+    heartbeatPing?: number;
+    heartbeatPong?: number;
 }

package/jest.config.js

@@ -0,0 +1,18 @@
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  moduleNameMapper: {
+    '^(\\.{1,2}/.*)\\.js$': '$1',
+  },
+  transform: {
+    '^.+\\.tsx?$': ['ts-jest', {
+      useESM: true,
+    }],
+  },
+  extensionsToTreatAsEsm: ['.ts'],
+  moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx', 'json', 'node'],
+  testMatch: ['**/__tests__/**/*.ts?(x)', '**/?(*.)+(spec|test).ts?(x)'],
+  collectCoverage: true,
+  coverageDirectory: 'coverage',
+  coverageReporters: ['text', 'lcov'],
+};

package/package.json

@@ -1,23 +1,27 @@
-{
-  "name": "docpouch-client",
-  "version": "0.8.2",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "scripts": {
-    "build": "tsc"
-  },
-  "keywords": [
-    "docPouch",
-    "API"
-  ],
-  "author": "Jan Frecè",
-  "license": "MIT",
-  "description": "A small class to more easily access the docPouch API",
-  "devDependencies": {
-    "@types/node": "^22.15.23",
-    "socket.io-client": "^4.8.1"
-  },
-  "dependencies": {
-    "typescript": "^5.8.3"
-  }
-}
+{
+  "name": "docpouch-client",
+  "version": "0.8.3",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "test": "jest"
+  },
+  "keywords": [
+    "docPouch",
+    "API"
+  ],
+  "author": "Jan Frecè",
+  "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"
+  },
+  "dependencies": {
+    "typescript": "^5.8.3"
+  }
+}

package/src/__tests__/index.test.ts

@@ -0,0 +1,489 @@
+import Index 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: Index;
+  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 Index(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 Index(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 Index(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 Index(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 Index(baseUrl, mockCallback);
+
+      // Verify that onAny was called
+      expect(indexWithCallback.socket.onAny).toHaveBeenCalled();
+    });
+  });
+});

package/src/index.ts

@@ -130,11 +130,11 @@ export default class Index {
     }
 
     getToken() {
-        return packetJson.version;
+        return this.token;
     }
 
     getVersion() {
-        return "0.0.1";
+        return packetJson.version;
     }
 }
 

package/tsconfig.json

@@ -12,8 +12,9 @@
     "rootDir": "./src",
     "declaration": true,
     "emitDeclarationOnly": false,
-    "resolveJsonModule": true
+    "resolveJsonModule": true,
+    "isolatedModules": true
   },
   "include": ["**/*.ts", "**/*.tsx"],
   "exclude": ["node_modules", "**/*.test.ts", "**/*.types.ts", "./dist/**/*"]
-}
+}