endee 1.0.6 → 1.0.8-dev.1

package/README.md

@@ -1,250 +1,381 @@
 # Endee - TypeScript Vector Database Client
 
-Endee is a TypeScript client for a vector database designed for maximum speed and efficiency. This package provides full type safety, modern ES module support, and optimized code for rapid Approximate Nearest Neighbor (ANN) searches on vector data.
+Endee is a TypeScript client for a local vector database designed for maximum speed and efficiency. This package provides full type safety, modern ES module support, and optimized code for rapid Approximate Nearest Neighbor (ANN) searches on vector data.
 
 ## Key Features
 
 - **TypeScript First**: Full type safety and IntelliSense support
 - **Fast ANN Searches**: Efficient similarity searches on vector data
 - **Multiple Distance Metrics**: Support for cosine, L2, and inner product distance metrics
+- **Hybrid Indexes**: Support for dense vectors, sparse vectors, and hybrid (dense + sparse) searches
 - **Metadata Support**: Attach and search with metadata and filters
-- **Client-Side Encryption**: Optional AES-256 encryption for your metadata
 - **High Performance**: Optimized for speed and efficiency
 - **Modern ES Modules**: Native ES module support with proper tree-shaking
 
+## Requirements
+
+- Node.js >= 18.0.0
+- Endee Local server running (see [Quick Start](https://docs.endee.io/quick-start))
+
 ## Installation
 
 ```bash
 npm install endee
 ```
 
-## Getting Your Auth Token
+## Quick Start
 
-1. Go to the [Endee Dashboard](https://dapp.endee.io)
-2. Sign up or log in to your account
-3. Navigate to **API Keys** section
-4. Click **Generate New Token**
-5. Copy the generated auth token and store it securely
+### Initialize the Client
 
-## Quick Start
+The Endee client connects to your local server (defaults to `http://127.0.0.1:8080/api/v1`):
 
 ```typescript
-import { Endee, Precision } from "endee";
+import { Endee, Precision } from 'endee';
+
+// Connect to local Endee server (defaults to localhost:8080)
+const client = new Endee();
+```
 
-// Initialize client with your Auth token
-const endee = new Endee("<auth-token>");
+**Using Authentication?** If your server has `NDD_AUTH_TOKEN` set, pass the same token when initializing:
+
+```typescript
+const client = new Endee('your-auth-token');
+```
+
+### Setting a Custom Base URL
+
+If your server runs on a different port, use `setBaseUrl()`:
+
+```typescript
+const client = new Endee();
 
-// Create a new index
-await endee.createIndex({
-  name: "my_vectors",
-  dimension: 1536, // Your vector dimension
-  spaceType: "cosine" // Distance metric (cosine, l2, ip)
+// Set custom base URL for non-default port
+client.setBaseUrl('http://0.0.0.0:8081/api/v1');
+```
+
+### Create a Dense Index
+
+```typescript
+import { Precision } from 'endee';
+
+await client.createIndex({
+  name: 'my_vectors',
+  dimension: 384,
+  spaceType: 'cosine',
+  precision: Precision.INT8D,
 });
+```
 
-// Get index reference
-const index = await endee.getIndex("my_vectors");
+**Dense Index Parameters:**
+
+| Parameter | Description |
+|-----------|-------------|
+| `name` | Unique name for your index |
+| `dimension` | Vector dimensionality (must match your embedding model's output) |
+| `spaceType` | Distance metric - `"cosine"`, `"l2"`, or `"ip"` (inner product) |
+| `M` | Graph connectivity - higher values increase recall but use more memory (default: 16) |
+| `efCon` | Construction-time parameter - higher values improve index quality (default: 128) |
+| `precision` | Quantization precision (default: `Precision.INT8D`) |
+
+### Create a Hybrid Index
+
+Hybrid indexes combine dense vector search with sparse vector search. Add the `sparseDimension` parameter:
+
+```typescript
+await client.createIndex({
+  name: 'hybrid_index',
+  dimension: 384,           // Dense vector dimension
+  sparseDimension: 30000,   // Sparse vector dimension (vocabulary size)
+  spaceType: 'cosine',
+  precision: Precision.INT8D,
+});
+```
+
+### List and Access Indexes
+
+```typescript
+// List all indexes
+const indexes = await client.listIndexes();
+
+// Get reference to an existing index
+const index = await client.getIndex('my_vectors');
+
+// Delete an index
+await client.deleteIndex('my_vectors');
+```
+
+## Upserting Vectors
+
+The `index.upsert()` method adds or updates vectors in an existing index.
+
+```typescript
+const index = await client.getIndex('my_index');
 
-// Insert vectors
 await index.upsert([
   {
-    id: "doc1",
-    vector: [0.1, 0.2, 0.3 /* ... */], // Your vector data
-    meta: { text: "Example document", category: "reference" },
+    id: 'vec1',
+    vector: [0.1, 0.2, 0.3 /* ... */],
+    meta: { title: 'First document' },
+    filter: { category: 'tech' },
+  },
+  {
+    id: 'vec2',
+    vector: [0.3, 0.4, 0.5 /* ... */],
+    meta: { title: 'Second document' },
+    filter: { category: 'science' },
   },
 ]);
+```
+
+**Vector Object Fields:**
+
+| Field | Required | Description |
+|-------|----------|-------------|
+| `id` | Yes | Unique identifier for the vector |
+| `vector` | Yes | Array of floats representing the embedding |
+| `meta` | No | Arbitrary metadata object |
+| `filter` | No | Key-value pairs for filtering during queries |
+
+## Querying the Index
 
-// Query similar vectors
+The `index.query()` method performs a similarity search.
+
+```typescript
 const results = await index.query({
-  vector: [0.2, 0.3, 0.4 /* ... */], // Query vector
-  topK: 10
+  vector: [0.15, 0.25 /* ... */],
+  topK: 5,
+  ef: 128,
+  includeVectors: true,
 });
 
-// Process results
 for (const item of results) {
   console.log(`ID: ${item.id}, Similarity: ${item.similarity}`);
-  console.log(`Metadata:`, item.meta);
 }
 ```
 
-## Basic Usage
+**Query Parameters:**
 
-### Initializing the Client
+| Parameter | Description |
+|-----------|-------------|
+| `vector` | Query vector (must match index dimension) |
+| `topK` | Number of results to return (default: 10, max: 512) |
+| `ef` | Search quality parameter (default: 128, max: 1024) |
+| `includeVectors` | Include vector data in results (default: false) |
 
-```typescript
-import { Endee } from "endee";
+## Filtered Querying
 
-// Production with specific region
-const endee = new Endee("<auth-token>");
+Use the `filter` parameter to restrict results. All filters are combined with **logical AND**.
 
-// Local development (defaults to http://127.0.0.1:8080/api/v1)
-const endee = new Endee();
+```typescript
+const results = await index.query({
+  vector: [0.15, 0.25 /* ... */],
+  topK: 5,
+  filter: [
+    { category: { $eq: 'tech' } },
+    { score: { $range: [80, 100] } },
+  ],
+});
 ```
 
-### Managing Indexes
+### Filtering Operators
 
-```typescript
-import { Precision } from "endee";
+| Operator | Description | Example |
+|----------|-------------|---------|
+| `$eq` | Exact match | `{ status: { $eq: 'published' } }` |
+| `$in` | Match any in list | `{ tags: { $in: ['ai', 'ml'] } }` |
+| `$range` | Numeric range (inclusive) | `{ score: { $range: [70, 95] } }` |
 
-// List all indexes
-const indexes = await endee.listIndexes();
+> **Note:** The `$range` operator supports values within **[0 - 999]**. Normalize larger values before upserting.
 
-// Create an index with custom parameters
-await endee.createIndex({
-  name: "my_custom_index",
-  dimension: 384,
-  spaceType: "l2", // space type (cosine, l2, ip)
-  M: 32, // M: Graph connectivity parameter
-  efCon: 256, // efCon: Construction-time parameter
-  precision: Precision.INT8D // Quantization precision (default: Precision.INT8D)
-});
+## Hybrid Search
 
-// Delete an index
-await endee.deleteIndex("my_index");
-```
+### Upserting Hybrid Vectors
 
-### Working with Vectors
+Provide both dense vectors and sparse representations:
 
 ```typescript
-// Get index reference
-const index = await endee.getIndex("my_index");
+const index = await client.getIndex('hybrid_index');
 
-// Insert multiple vectors in a batch
 await index.upsert([
   {
-    id: "vec1",
-    vector: [/* ... */], // Your vector
-    meta: { title: "First document" },
-    filter: { tags: "important" },
+    id: 'doc1',
+    vector: [0.1, 0.2 /* ... */],           // Dense vector
+    sparseIndices: [10, 50, 200],            // Non-zero term positions
+    sparseValues: [0.8, 0.5, 0.3],           // Weights for each position
+    meta: { title: 'Document 1' },
   },
   {
-    id: "vec2",
-    vector: [/* ... */], // Another vector
-    filter: { visibility: "public" }, // Optional filter values
+    id: 'doc2',
+    vector: [0.3, 0.4 /* ... */],
+    sparseIndices: [15, 100, 500],
+    sparseValues: [0.9, 0.4, 0.6],
+    meta: { title: 'Document 2' },
   },
 ]);
+```
+
+**Hybrid Vector Fields:**
+
+| Field | Required | Description |
+|-------|----------|-------------|
+| `id` | Yes | Unique identifier |
+| `vector` | Yes | Dense embedding vector |
+| `sparseIndices` | Yes (hybrid) | Non-zero term positions in sparse vector |
+| `sparseValues` | Yes (hybrid) | Weights for each sparse index |
+| `meta` | No | Metadata dictionary |
+| `filter` | No | Filter fields |
+
+> **Important:** `sparseIndices` and `sparseValues` must have the same length. Values in `sparseIndices` must be within `[0, sparseDimension)`.
+
+### Querying Hybrid Index
+
+Provide both dense and sparse query vectors:
 
-// Query with custom parameters
+```typescript
 const results = await index.query({
-  vector: [/* ... */], // Query vector
-  topK: 5, // Number of results to return
-  filter: [{ tags: { "$eq": "important" } }], // Filter array with operators
-  ef: 128, // Runtime parameter for search quality
-  includeVectors: true, // Include vector data in results
+  vector: [0.15, 0.25 /* ... */],       // Dense query
+  sparseIndices: [10, 100, 300],         // Sparse query positions
+  sparseValues: [0.7, 0.5, 0.4],         // Sparse query weights
+  topK: 5,
 });
 
-// Delete vectors
-await index.deleteVector("vec1");
-await index.deleteWithFilter({ visibility: { "$eq": "public" } });
+for (const item of results) {
+  console.log(`ID: ${item.id}, Similarity: ${item.similarity}`);
+}
+```
 
-// Get a specific vector
-const vector = await index.getVector("vec1");
+You can also query with:
+- **Dense only**: Provide only `vector`
+- **Sparse only**: Provide only `sparseIndices` and `sparseValues`
+- **Hybrid**: Provide all three for combined results
 
-// Get index description
-const description = await index.describe();
-console.log(description);
-```
+## Deletion Methods
 
-## Filtering
+### Delete by ID
+Delete vector with a specifc vector id.
+```typescript
+await index.deleteVector('vec1');
+```
+### Delete by Filter
+Delete all vectors matching specific filters.
+```typescript
+await index.deleteWithFilter([{'category': {'$eq' : 'tech'}}]);
+```
 
-Endee supports structured filtering using operators like `$eq`, `$in`, and `$range`. For detailed documentation on filtering, see the [official documentation](https://docs.endee.io/sdks/typescript/usage#filtered-querying).
+### Delete Index
+Delete an entire Index.
+```typescript
+await client.deleteIndex('my_index');
+```
 
-## Encryption
+> **Warning:** Deletion operations are **irreversible**.
 
-Endee supports optional client-side encryption for your metadata using AES-256-CBC. When encryption is enabled, your metadata is encrypted before being sent to the server and decrypted when retrieved. The encryption key never leaves your environment.
+## Additional Operations
 
-### Generating an Encryption Key
+### Get Vector by ID
 
 ```typescript
-import { Endee } from "endee";
-
-const endee = new Endee("<your-auth-token>");
+const vector = await index.getVector('vec1');
+```
 
-// Generate a secure 256-bit encryption key
-const key = endee.generateKey();
+### Describe Index
 
+```typescript
+const info = index.describe();
+console.log(info);
+// { name, spaceType, dimension, sparseDimension, isHybrid, count, precision, M }
 ```
 
-> **Important**: Store your encryption key securely. If you lose the key, you will not be able to decrypt your data. The key is a 64-character hexadecimal string (256 bits).
+## Precision Options
 
-### Creating an Encrypted Index
+Endee supports different quantization precision levels:
 
 ```typescript
-// Create an index with encryption enabled
-await endee.createIndex({
-  name: "encrypted_index",
-  dimension: 128,
-  spaceType: "cosine",
-  key: key // Pass your encryption key
-});
+import { Precision } from 'endee';
+
+Precision.BINARY;   // Binary quantization (1-bit) - smallest storage, fastest search
+Precision.INT8D;    // 8-bit integer quantization (default) - balanced performance
+Precision.INT16D;   // 16-bit integer quantization - higher precision
+Precision.FLOAT16;  // 16-bit floating point - good balance
+Precision.FLOAT32;  // 32-bit floating point - highest precision
 ```
 
-### Working with Encrypted Data
+**Choosing Precision:**
+
+- `BINARY`: Best for very large datasets where speed and storage are critical
+- `INT8D` (default): Recommended for most use cases - good balance of accuracy and performance
+- `INT16D`: When you need better accuracy than INT8D but less storage than FLOAT32
+- `FLOAT16`: Good compromise between precision and storage for embeddings
+- `FLOAT32`: When you need maximum precision and storage is not a concern
+
+## Complete Example
 
 ```typescript
-// Get index reference with encryption key
-const index = await endee.getIndex("encrypted_index", key);
+import { Endee, Precision } from 'endee';
+
+// Initialize client
+const client = new Endee();
+
+// Create a dense index
+await client.createIndex({
+  name: 'documents',
+  dimension: 384,
+  spaceType: 'cosine',
+  precision: Precision.INT8D,
+});
 
-// Insert vectors - metadata will be automatically encrypted
+// Get the index
+const index = await client.getIndex('documents');
+
+// Add vectors
 await index.upsert([
   {
-    id: "secret_doc",
-    vector: [0.1, 0.2, 0.3 /* ... */], // Your vector data,
-    meta: { 
-      content: "This is sensitive information",
-      userId: "user123"
-    },
+    id: 'doc1',
+    vector: [0.1, 0.2 /* ... 384 dimensions */],
+    meta: { title: 'First Document' },
+    filter: { category: 'tech' },
+  },
+  {
+    id: 'doc2',
+    vector: [0.3, 0.4 /* ... 384 dimensions */],
+    meta: { title: 'Second Document' },
+    filter: { category: 'science' },
   },
 ]);
 
-// Query vectors - metadata will be automatically decrypted
+// Query the index
 const results = await index.query({
-  vector: [0.2, 0.4, 0.3 /* ... */], // Your query data,
-  topK: 10,
+  vector: [0.15, 0.25 /* ... */],
+  topK: 5,
 });
 
-// Results contain decrypted metadata
 for (const item of results) {
-  console.log(item.meta); // { content: "This is sensitive information", userId: "user123" }
+  console.log(`ID: ${item.id}, Similarity: ${item.similarity}`);
 }
 ```
 
-### Key Points
-
-- **Encryption is optional**: Only enable it if you need to protect sensitive metadata
-- **Key management is your responsibility**: Store keys securely (e.g., environment variables, secret managers)
-- **Vectors are not encrypted**: Only metadata is encrypted; vector data remains searchable
-- **Key verification**: The system verifies the key checksum when accessing an encrypted index
-- **No key recovery**: Lost keys cannot be recovered; encrypted data becomes inaccessible
+## API Reference
 
-## Precision Options
+### Endee Class
 
-Endee supports different quantization precision levels to optimize storage and performance:
+| Method | Description |
+|--------|-------------|
+| `createIndex(options)` | Create a new index (add `sparseDimension` for hybrid) |
+| `listIndexes()` | List all indexes |
+| `deleteIndex(name)` | Delete an index |
+| `getIndex(name)` | Get reference to an index |
+| `setBaseUrl(url)` | Set a custom base URL |
 
-```typescript
-import { Precision } from "endee";
-
-// Available precision options:
-Precision.BINARY   // Binary quantization (1-bit) - smallest storage, fastest search
-Precision.INT8D    // 8-bit integer quantization (default) - balanced performance
-Precision.INT16D   // 16-bit integer quantization - higher precision
-Precision.FLOAT16  // 16-bit floating point - good balance
-Precision.FLOAT32  // 32-bit floating point - highest precision
-
-// Example usage:
-await endee.createIndex({
-  name: "high_precision_index",
-  dimension: 1536,
-  spaceType: "cosine",
-  precision: Precision.FLOAT32 // Use full precision
-});
-```
+### Index Class
 
-**Choosing Precision:**
-- `BINARY`: Best for very large datasets where speed and storage are critical
-- `INT8D` (default): Recommended for most use cases - good balance of accuracy and performance
-- `INT16D`: When you need better accuracy than INT8D but less storage than FLOAT32
-- `FLOAT16`: Good compromise between precision and storage for embeddings
-- `FLOAT32`: When you need maximum precision and storage is not a concern
+| Method | Description |
+|--------|-------------|
+| `upsert(vectors)` | Insert or update vectors |
+| `query(options)` | Search for similar vectors |
+| `deleteVector(id)` | Delete a vector by ID |
+| `deleteWithFilter(filter)` | Delete vectors by Filter |
+| `getVector(id)` | Get a vector by ID |
+| `describe()` | Get index info |
 
 ## TypeScript Types
 
@@ -258,15 +389,10 @@ import type {
   CreateIndexOptions,
   IndexDescription,
   SpaceType,
-  Precision
-} from "endee";
+  Precision,
+} from 'endee';
 ```
 
-## Requirements
-
-- Node.js >= 18.0.0
-- TypeScript >= 5.0.0 (for development)
-
 ## License
 
 MIT

package/dist/crypto.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"crypto.d.ts","sourceRoot":"","sources":["../src/crypto.ts"],"names":[],"mappings":"AAAA;;GAEG;AAKH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAItD;AAED,wBAAgB,OAAO,CACrB,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,GAAG,SAAS,EAC/C,GAAG,GAAE,MAAM,GAAG,IAAW,GACxB,MAAM,CAWR;AAED,wBAAgB,SAAS,CACvB,UAAU,EACN,MAAM,GACN,UAAU,GACV,MAAM,GACN,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACvB,IAAI,GACJ,SAAS,EACb,GAAG,GAAE,MAAM,GAAG,IAAW,GACxB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAsCzB;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAuB/D;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAyB/D"}
+{"version":3,"file":"crypto.d.ts","sourceRoot":"","sources":["../src/crypto.ts"],"names":[],"mappings":"AAAA;;GAEG;AAKH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAItD;AAED,wBAAgB,OAAO,CACrB,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,GAAG,SAAS,EAC/C,GAAG,GAAE,MAAM,GAAG,IAAW,GACxB,MAAM,CAWR;AAED,wBAAgB,SAAS,CACvB,UAAU,EAAE,MAAM,GAAG,UAAU,GAAG,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,GAAG,SAAS,EACrF,GAAG,GAAE,MAAM,GAAG,IAAW,GACxB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAgCzB;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAuB/D;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAsB/D"}

package/dist/crypto.js

@@ -1,8 +1,8 @@
 /**
  * Cryptographic utilities for Endee-DB
  */
-import * as zlib from "zlib";
-import crypto from "crypto";
+import * as zlib from 'zlib';
+import crypto from 'crypto';
 export function getChecksum(key) {
     // Convert last two characters of key to integer (hex)
     if (key === null)
@@ -13,7 +13,7 @@ export function jsonZip(obj, key = null) {
     if (!obj || Object.keys(obj).length === 0)
         return Buffer.alloc(0);
     const jsonStr = JSON.stringify(obj);
-    const compressed = zlib.deflateSync(Buffer.from(jsonStr, "utf-8"));
+    const compressed = zlib.deflateSync(Buffer.from(jsonStr, 'utf-8'));
     // If key is provided, encrypt the compressed data
     if (key) {
         return aesEncrypt(compressed, key);
@@ -23,12 +23,12 @@ export function jsonZip(obj, key = null) {
 export function jsonUnzip(compressed, key = null) {
     if (!compressed || (compressed instanceof Buffer && compressed.length === 0))
         return {};
-    if (typeof compressed === "object" &&
+    if (typeof compressed === 'object' &&
         !Buffer.isBuffer(compressed) &&
         !(compressed instanceof Uint8Array)) {
         return compressed;
     }
-    if (typeof compressed === "string") {
+    if (typeof compressed === 'string') {
         try {
             return JSON.parse(compressed);
         }
@@ -37,17 +37,15 @@ export function jsonUnzip(compressed, key = null) {
         }
     }
     try {
-        let buffer = Buffer.isBuffer(compressed)
-            ? compressed
-            : Buffer.from(compressed);
+        let buffer = Buffer.isBuffer(compressed) ? compressed : Buffer.from(compressed);
         // If key is provided, decrypt the compressed data first
         if (key) {
             buffer = aesDecrypt(buffer, key);
         }
         const decompressed = zlib.inflateSync(buffer);
-        return JSON.parse(decompressed.toString("utf-8"));
+        return JSON.parse(decompressed.toString('utf-8'));
     }
-    catch (err) {
+    catch {
         return {};
     }
 }
@@ -60,15 +58,15 @@ export function jsonUnzip(compressed, key = null) {
  */
 export function aesEncrypt(data, keyHex) {
     // Convert hex key to bytes
-    const key = Buffer.from(keyHex, "hex");
+    const key = Buffer.from(keyHex, 'hex');
     if (key.length !== 32) {
         // 256 bits = 32 bytes
-        throw new Error("Key must be 256 bits (64 hex characters)");
+        throw new Error('Key must be 256 bits (64 hex characters)');
     }
     // Generate a random 16-byte IV
     const iv = crypto.randomBytes(16);
     // Create cipher
-    const cipher = crypto.createCipheriv("aes-256-cbc", key, iv);
+    const cipher = crypto.createCipheriv('aes-256-cbc', key, iv);
     // Pad data to 16-byte boundary (PKCS7 padding)
     const paddedData = pkcs7Pad(data);
     // Encrypt
@@ -85,22 +83,19 @@ export function aesEncrypt(data, keyHex) {
  */
 export function aesDecrypt(data, keyHex) {
     // Convert hex key to bytes
-    const key = Buffer.from(keyHex, "hex");
+    const key = Buffer.from(keyHex, 'hex');
     if (key.length !== 32) {
         // 256 bits = 32 bytes
-        throw new Error("Key must be 256 bits (64 hex characters)");
+        throw new Error('Key must be 256 bits (64 hex characters)');
     }
     // Extract IV and ciphertext
     const iv = data.subarray(0, 16);
     const ciphertext = data.subarray(16);
     // Create decipher
-    const decipher = crypto.createDecipheriv("aes-256-cbc", key, iv);
+    const decipher = crypto.createDecipheriv('aes-256-cbc', key, iv);
     decipher.setAutoPadding(false); // We handle padding manually
     // Decrypt
-    const paddedData = Buffer.concat([
-        decipher.update(ciphertext),
-        decipher.final(),
-    ]);
+    const paddedData = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
     // Remove PKCS7 padding
     return pkcs7Unpad(paddedData);
 }