montycat 1.1.4 → 1.1.5

package/dist/classes/generic.d.ts

@@ -173,5 +173,18 @@ declare class GenericKV {
      * @returns The current instance of GenericKV.
      */
     showStoreProperties(): this;
+    /**
+     * Subscribes to changes in the keyspace.
+     * Inherited by InMemory and Persistent - `this.persistent` resolves correctly per subclass.
+     * @param callback - A callback function to handle incoming data.
+     * @param key - A specific key to subscribe to.
+     * @param customKey - A custom key to subscribe to (will be hashed with XXH32).
+     * @returns A promise that resolves with a subscription handle ({ stop() }).
+     */
+    static subscribe({ callback, key, customKey }: {
+        callback?: (data: any) => void;
+        key?: string;
+        customKey?: string;
+    }): Promise<any>;
 }
 export default GenericKV;

package/dist/classes/generic.js

@@ -34,15 +34,15 @@ class GenericKV {
      * @return A promise that resolves with the retrieved value.
      */
     static async getValue({ key = "", customKey = null, withPointers = false, keyIncluded = false, pointersMetadata = false } = {}) {
-        if (pointersMetadata && withPointers) {
-            throw new Error("You select both pointers value and pointers metadata. Choose one");
-        }
         try {
+            if (key && customKey) {
+                throw new Error("Provide either 'key' or 'customKey', not both.");
+            }
+            if (!key && !customKey) {
+                throw new Error("Provide either 'key' or 'customKey'.");
+            }
             if (customKey)
                 key = convertCustomKey(customKey);
-            if (!key) {
-                throw new Error("No key provided");
-            }
             this.command = "get_value";
             const query = convertToBinaryQuery(this, { key, withPointers, keyIncluded, pointersMetadata });
             return runQuery(this, query);
@@ -59,11 +59,14 @@ class GenericKV {
      * */
     static async listAllDependingKeys({ key = "", customKey = null } = {}) {
         try {
+            if (key && customKey) {
+                throw new Error("Provide either 'key' or 'customKey', not both.");
+            }
+            if (!key && !customKey) {
+                throw new Error("Provide either 'key' or 'customKey'.");
+            }
             if (customKey)
                 key = convertCustomKey(customKey);
-            if (!key) {
-                throw new Error("No key provided");
-            }
             this.command = "list_all_depending_keys";
             const query = convertToBinaryQuery(this, { key });
             return runQuery(this, query);
@@ -85,6 +88,9 @@ class GenericKV {
      * */
     static async deleteKey({ key = "", customKey = null } = {}) {
         try {
+            if (key && customKey) {
+                throw new Error("Provide either 'key' or 'customKey', not both.");
+            }
             if (customKey)
                 key = convertCustomKey(customKey);
             if (!key) {
@@ -301,5 +307,29 @@ class GenericKV {
     showStoreProperties() {
         return this;
     }
+    /**
+     * Subscribes to changes in the keyspace.
+     * Inherited by InMemory and Persistent - `this.persistent` resolves correctly per subclass.
+     * @param callback - A callback function to handle incoming data.
+     * @param key - A specific key to subscribe to.
+     * @param customKey - A custom key to subscribe to (will be hashed with XXH32).
+     * @returns A promise that resolves with a subscription handle ({ stop() }).
+     */
+    static async subscribe({ callback, key, customKey }) {
+        if (key && customKey) {
+            throw new Error("Provide either 'key' or 'customKey', not both.");
+        }
+        const effectiveKey = customKey ? convertCustomKey(customKey) : (key || null);
+        const queryObj = {
+            subscribe: true,
+            store: this.store,
+            keyspace: this.keyspace,
+            username: this.username,
+            password: this.password,
+            persistent: this.persistent,
+            key: effectiveKey,
+        };
+        return await runQuery(this, JSON.stringify(queryObj), callback, true);
+    }
 }
 export default GenericKV;

package/dist/core/persistent.d.ts

@@ -6,8 +6,6 @@ import GenericKV from '../classes/generic.js';
 declare class Persistent extends GenericKV {
     static persistent: boolean;
     static distributed: boolean;
-    static cache: number | null;
-    static compression: boolean;
     keyspace: string;
     constructor(options: {
         keyspace: string;
@@ -15,40 +13,6 @@ declare class Persistent extends GenericKV {
         password: string;
         [key: string]: any;
     });
-    /**
-     * Subscribes to changes in the persistent store based on the provided options.
-     * @param callback - A callback function to handle incoming data.
-     * @param key - A specific key to subscribe to.
-     * @param customKey - A custom key to subscribe to.
-     * @return A promise that resolves with the result of the subscription.
-     * Note: Subscriptions are only allowed on non-persistent keyspaces, so this method will throw an error if called on a persistent keyspace.
-     * The effective key for the subscription is determined by the presence of a custom key or a regular key, with the custom key taking precedence if both are provided.
-     * The subscription query is constructed with the appropriate parameters and sent to the server using the runQuery function, with the callback function passed to handle incoming data.
-     * If the subscription is successful, the promise will resolve with the result of the subscription; otherwise, it will reject with an error.
-     * Error handling is implemented to ensure that subscriptions are not allowed on persistent keyspaces, and that a key is provided for the subscription.
-     * The method is designed to facilitate real-time updates and notifications for changes in the keyspace, allowing clients to react to data changes as they occur.
-     * Overall, this method provides a mechanism for clients to stay informed about changes in the persistent store, while enforcing the constraints of the keyspace type and ensuring that necessary parameters are provided for the subscription.
-     * @throws Will throw an error if subscriptions are attempted on a persistent keyspace or if no key is provided for the subscription.
-     * @example
-     * Persistent.subscribe({
-     *   callback: (data) => {
-     *    console.log("Received data:", data);
-     *  },
-     *  key: "myKey"
-     * });
-     * @example
-     * Persistent.subscribe({
-     *  callback: (data) => {
-     *   console.log("Received data for custom key:", data);
-     * },
-     * customKey: "myCustomKey"
-     * });
-     */
-    static subscribe({ callback, key, customKey }: {
-        callback?: (data: any) => void;
-        key?: string;
-        customKey?: string;
-    }): Promise<any>;
     /**
      * Inserts a value into the persistent store.
      * @param value - The value to insert.
@@ -112,16 +76,22 @@ declare class Persistent extends GenericKV {
     }): Promise<any>;
     /**
      * Updates the cache and compression settings for the persistent store.
-     * @param cache - The cache settings to apply.
-     * @param compression - Whether to enable compression.
+     * @param options - Optional cache (number) and compression (boolean) settings.
      * @return A promise that resolves with the result of the update.
      */
-    static updateCacheAndCompression(): Promise<any>;
+    static updateCacheAndCompression({ cache, compression }?: {
+        cache?: number;
+        compression?: boolean;
+    }): Promise<any>;
     /**
      * Creates a keyspace in the persistent store.
+     * @param options - Optional cache (number) and compression (boolean) settings.
      * @return A promise that resolves with the result of the keyspace creation.
      */
-    static createKeyspace(): Promise<any>;
+    static createKeyspace({ cache, compression }?: {
+        cache?: number;
+        compression?: boolean;
+    }): Promise<any>;
 }
 /**
  * PersistentDistributed class that extends Persistent for distributed persistent keyspace operations.

package/dist/core/persistent.js

@@ -7,55 +7,11 @@ import GenericKV from '../classes/generic.js';
 class Persistent extends GenericKV {
     static persistent = true;
     static distributed = false;
-    static cache = null;
-    static compression = false;
     keyspace;
     constructor(options) {
         super(options);
         this.keyspace = options.keyspace;
     }
-    /**
-     * Subscribes to changes in the persistent store based on the provided options.
-     * @param callback - A callback function to handle incoming data.
-     * @param key - A specific key to subscribe to.
-     * @param customKey - A custom key to subscribe to.
-     * @return A promise that resolves with the result of the subscription.
-     * Note: Subscriptions are only allowed on non-persistent keyspaces, so this method will throw an error if called on a persistent keyspace.
-     * The effective key for the subscription is determined by the presence of a custom key or a regular key, with the custom key taking precedence if both are provided.
-     * The subscription query is constructed with the appropriate parameters and sent to the server using the runQuery function, with the callback function passed to handle incoming data.
-     * If the subscription is successful, the promise will resolve with the result of the subscription; otherwise, it will reject with an error.
-     * Error handling is implemented to ensure that subscriptions are not allowed on persistent keyspaces, and that a key is provided for the subscription.
-     * The method is designed to facilitate real-time updates and notifications for changes in the keyspace, allowing clients to react to data changes as they occur.
-     * Overall, this method provides a mechanism for clients to stay informed about changes in the persistent store, while enforcing the constraints of the keyspace type and ensuring that necessary parameters are provided for the subscription.
-     * @throws Will throw an error if subscriptions are attempted on a persistent keyspace or if no key is provided for the subscription.
-     * @example
-     * Persistent.subscribe({
-     *   callback: (data) => {
-     *    console.log("Received data:", data);
-     *  },
-     *  key: "myKey"
-     * });
-     * @example
-     * Persistent.subscribe({
-     *  callback: (data) => {
-     *   console.log("Received data for custom key:", data);
-     * },
-     * customKey: "myCustomKey"
-     * });
-     */
-    static async subscribe({ callback, key, customKey }) {
-        const effectiveKey = customKey ? convertCustomKey(customKey) : (key || null);
-        const queryObj = {
-            subscribe: true,
-            key: effectiveKey,
-            keyspace: this.keyspace,
-            store: this.store,
-            username: this.username,
-            password: this.password
-        };
-        const query = JSON.stringify(queryObj);
-        return await runQuery(this, query, callback, true);
-    }
     /**
      * Inserts a value into the persistent store.
      * @param value - The value to insert.
@@ -139,21 +95,22 @@ class Persistent extends GenericKV {
     }
     /**
      * Updates the cache and compression settings for the persistent store.
-     * @param cache - The cache settings to apply.
-     * @param compression - Whether to enable compression.
+     * @param options - Optional cache (number) and compression (boolean) settings.
      * @return A promise that resolves with the result of the update.
      */
-    static async updateCacheAndCompression() {
+    static async updateCacheAndCompression({ cache, compression } = {}) {
         if (!this.persistent) {
             throw new Error("Cache and compression settings can only be updated for persistent keyspaces.");
         }
+        const cacheValue = cache !== undefined ? cache.toString() : "0";
+        const compressionValue = compression === true ? "y" : "n";
         const query = {
             raw: [
                 "update-cache-compression",
                 "store", this.store,
                 "keyspace", this.keyspace,
-                "cache", this.cache ? this.cache : "0",
-                "compression", this.compression ? "y" : "n"
+                "cache", cacheValue,
+                "compression", compressionValue
             ],
             credentials: [this.username, this.password],
         };
@@ -161,9 +118,12 @@ class Persistent extends GenericKV {
     }
     /**
      * Creates a keyspace in the persistent store.
+     * @param options - Optional cache (number) and compression (boolean) settings.
      * @return A promise that resolves with the result of the keyspace creation.
      */
-    static async createKeyspace() {
+    static async createKeyspace({ cache, compression } = {}) {
+        const cacheValue = cache !== undefined ? cache.toString() : "0";
+        const compressionValue = compression === true ? "y" : "n";
         const query = {
             raw: [
                 "create-keyspace",
@@ -171,8 +131,8 @@ class Persistent extends GenericKV {
                 "keyspace", this.keyspace,
                 "persistent", this.persistent ? "y" : "n",
                 "distributed", this.distributed ? "y" : "n",
-                "cache", this.cache ? this.cache : "0",
-                "compression", this.compression ? "y" : "n"
+                "cache", cacheValue,
+                "compression", compressionValue
             ],
             credentials: [this.username, this.password],
         };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "montycat",
-  "version": "1.1.4",
+  "version": "1.1.5",
   "description": "A Node.js client for Montycat, NoSQL database utilizing Data Mesh architecture.",
   "type": "module",
   "main": "dist/index.js",