montycat 1.0.2

package/dist/core/engine.js

@@ -0,0 +1,284 @@
+import net from 'net';
+import JSONbigBase from 'json-bigint';
+const JSONbig = JSONbigBase({ storeAsString: true });
+/** * Enum for valid permissions.
+ * @enum
+ * */
+var ValidPermissions;
+(function (ValidPermissions) {
+    ValidPermissions["READ"] = "read";
+    ValidPermissions["WRITE"] = "write";
+    ValidPermissions["ALL"] = "all";
+})(ValidPermissions || (ValidPermissions = {}));
+/**
+ * Represents the configuration and connection details for a communication engine.
+ * This class allows you to connect to a MontyCat server and perform operations such as creating stores, managing owners, and granting/revoking permissions.
+ * @class
+ * @param {EngineConfig} config - The configuration for the engine, including host, port, username, password, and store.
+ * @example
+ *
+ *  const engine = new Engine({
+ *    host: 'localhost',
+ *    port: 3000,
+ *    username: 'admin',
+ *    password: 'admin',
+ *    store: 'test_store',
+ *  });
+ *
+ */
+class Engine {
+    host;
+    port;
+    username;
+    password;
+    store;
+    constructor({ host = null, port = null, username = null, password = null, store = null } = {}) {
+        this.host = host;
+        this.port = port;
+        this.username = username;
+        this.password = password;
+        this.store = store;
+    }
+    /**
+     * Creates an Engine instance from a URI string in the format:
+     * montycat://host/port/username/password[/store]
+     */
+    static fromUri(uri) {
+        if (!uri.startsWith('montycat://')) {
+            throw new Error("URI must use 'montycat://' protocol");
+        }
+        const parts = uri.slice('montycat://'.length).split('/');
+        if (parts.length !== 4 && parts.length !== 5) {
+            throw new Error('Missing or extra parts in URI');
+        }
+        const [host, portStr, username, password, store = null] = parts;
+        if (!host || !portStr || !username || !password) {
+            throw new Error('Host, port, username, and password must be non-empty');
+        }
+        const port = parseInt(portStr, 10);
+        if (isNaN(port)) {
+            throw new Error('Port must be an integer');
+        }
+        return new Engine({ host, port, username, password, store });
+    }
+    /**
+     * Creates a store with the specified persistence option.
+     * @param {Object} options - Options for creating the store.
+     * @param {boolean} [options.persistent=false] - Whether to create a persistent store.
+     * @returns {Promise<unknown>} A promise that resolves with the result of the store creation.
+     */
+    async createStore({ persistent = false } = {}) {
+        const rawQuery = {
+            raw: ['create-store', 'store', this.store, 'persistent', persistent ? 'y' : 'n'],
+            credentials: [this.username, this.password],
+        };
+        return sendData(this.host, this.port, JSONbig.stringify(rawQuery));
+    }
+    /**
+     * Removes a store with the specified persistence option.
+     * @param {Object} options - Options for removing the store.
+     * @param {boolean} [options.persistent=false] - Whether to remove a persistent store.
+     * @returns {Promise<unknown>} A promise that resolves with the result of the store removal.
+     */
+    async removeStore({ persistent = false } = {}) {
+        const rawQuery = {
+            raw: ['remove-store', 'store', this.store, 'persistent', persistent ? 'y' : 'n'],
+            credentials: [this.username, this.password],
+        };
+        return sendData(this.host, this.port, JSONbig.stringify(rawQuery));
+    }
+    /**
+     * Creates an owner with the specified username and password.
+     * @param {string} owner - The username of the owner to create.
+     * @param {string} password - The password for the owner.
+     * @returns {Promise<unknown>} A promise that resolves with the result of the owner creation.
+     */
+    async createOwner(owner, password) {
+        const rawQuery = {
+            raw: ['create-owner', 'username', owner, 'password', password],
+            credentials: [this.username, this.password],
+        };
+        return sendData(this.host, this.port, JSONbig.stringify(rawQuery));
+    }
+    async removeOwner(owner) {
+        const rawQuery = {
+            raw: ['remove-owner', 'username', owner],
+            credentials: [this.username, this.password],
+        };
+        return sendData(this.host, this.port, JSONbig.stringify(rawQuery));
+    }
+    /**
+     * Lists all owners in the store.
+     * @returns {Promise<unknown>} A promise that resolves with the list of owners.
+     */
+    async listOwners() {
+        const rawQuery = {
+            raw: ['list-owners'],
+            credentials: [this.username, this.password],
+        };
+        return sendData(this.host, this.port, JSONbig.stringify(rawQuery));
+    }
+    /**
+     * Grants a permission to an owner for specified keyspaces.
+     * @param {string} owner - The username of the owner to grant permission to.
+     * @param {ValidPermissions} permission - The permission to grant (read, write, all).
+     * @param {string | GenericKV[] | string[] | { keyspace: string }} [keyspaces] - The keyspaces to grant permission for.
+     * @returns {Promise<unknown>} A promise that resolves with the result of the grant operation.
+     */
+    async grantTo(owner, permission, keyspaces) {
+        const query = {
+            raw: ['grant-to', 'owner', owner, 'permission', permission, 'store', this.store],
+            credentials: [this.username, this.password],
+        };
+        if (keyspaces) {
+            query.raw.push('keyspaces');
+            if (typeof keyspaces === 'string') {
+                query.raw.push(keyspaces);
+            }
+            else if (Array.isArray(keyspaces)) {
+                keyspaces.forEach(each => {
+                    if (typeof each === 'object' && each.hasOwnProperty('keyspace')) {
+                        query.raw.push(each.keyspace);
+                    }
+                    else if (typeof each === 'string') {
+                        query.raw.push(each);
+                    }
+                });
+            }
+            else if (typeof keyspaces === 'object' && keyspaces.hasOwnProperty('keyspace')) {
+                query.raw.push(keyspaces.keyspace);
+            }
+        }
+        return sendData(this.host, this.port, JSONbig.stringify(query));
+    }
+    /**
+     * Revokes a permission from an owner for specified keyspaces.
+     * @param {string} owner - The username of the owner to revoke permission from.
+     * @param {ValidPermissions} permission - The permission to revoke (read, write, all).
+     * @param {string | GenericKV[] | string[] | { keyspace: string }} [keyspaces] - The keyspaces to revoke permission for.
+     * @returns {Promise<unknown>} A promise that resolves with the result of the revoke operation.
+     */
+    async revokeFrom(owner, permission, keyspaces) {
+        const validPermissions = ['read', 'write', 'all'];
+        if (!validPermissions.includes(permission)) {
+            throw new Error(`Invalid permission: ${permission}. Valid permissions are: ${validPermissions}`);
+        }
+        const query = {
+            raw: ['revoke-from', 'owner', owner, 'permission', permission, 'store', this.store],
+            credentials: [this.username, this.password],
+        };
+        if (keyspaces) {
+            query.raw.push('keyspaces');
+            if (typeof keyspaces === 'string') {
+                query.raw.push(keyspaces);
+            }
+            else if (Array.isArray(keyspaces)) {
+                keyspaces.forEach(each => {
+                    if (typeof each === 'object' && each.hasOwnProperty('keyspace')) {
+                        query.raw.push(each.keyspace);
+                    }
+                    else if (typeof each === 'string') {
+                        query.raw.push(each);
+                    }
+                });
+            }
+            else if (typeof keyspaces === 'object' && keyspaces.hasOwnProperty('keyspace')) {
+                query.raw.push(keyspaces.keyspace);
+            }
+        }
+        return sendData(this.host, this.port, JSONbig.stringify(query));
+    }
+    /**
+     * Retrieves the structure of the store.
+     * @returns {Promise<unknown>} A promise that resolves with the structure of the store
+     * */
+    async getStructureAvailable() {
+        const rawQuery = {
+            raw: ['get-structure-available'],
+            credentials: [this.username, this.password],
+        };
+        return sendData(this.host, this.port, JSONbig.stringify(rawQuery));
+    }
+}
+/**
+ * Sends a string to the specified host and port, and returns the parsed response.
+ * @param {string} host - The host to connect to.
+ * @param {number} port - The port to connect to.
+ * @param {string} string - The string to send.
+ * @returns {Promise<unknown>} A promise that resolves with the parsed response.
+ */
+async function sendData(host, port, string) {
+    return new Promise((resolve) => {
+        const client = new net.Socket({
+            readable: true,
+            writable: true,
+        });
+        let response = '';
+        client.connect(port, host, () => {
+            client.write(string + '\n');
+        });
+        client.on('data', (data) => {
+            response += data.toString();
+            if (response.includes('\n')) {
+                try {
+                    const parsedResponse = recursiveParseJSON(response);
+                    client.destroy();
+                    resolve(parsedResponse);
+                }
+                catch (err) {
+                    // Ignore parsing errors for now; handled in 'end' event
+                }
+            }
+        });
+        client.on('end', () => {
+            try {
+                const parsedResponse = recursiveParseJSON(response);
+                resolve(parsedResponse);
+            }
+            catch (err) {
+                resolve('Incomplete or invalid response');
+            }
+        });
+        client.on('timeout', () => {
+            resolve('Operation timed out');
+            client.destroy();
+        });
+        client.on('error', (err) => {
+            resolve(`Connection error: ${err.message}`);
+            client.destroy();
+        });
+        client.setTimeout(120000);
+    });
+}
+/**
+ * Recursively parses JSON data, handling BigInt and other types.
+ * @param {unknown} data - The data to parse.
+ * @returns {unknown} The parsed data.
+ */
+function recursiveParseJSON(data) {
+    if (typeof data === 'string') {
+        if (/^\d+$/.test(data) && BigInt(data) <= 18446744073709551615n) {
+            return data;
+        }
+        try {
+            const parsedData = JSONbig.parse(data);
+            return recursiveParseJSON(parsedData);
+        }
+        catch {
+            return data;
+        }
+    }
+    else if (Array.isArray(data)) {
+        return data.map((item) => recursiveParseJSON(item));
+    }
+    else if (typeof data === 'object' && data !== null) {
+        return Object.fromEntries(Object.entries(data).map(([key, value]) => {
+            const parsedKey = isNaN(parseInt(key, 10)) ? key : parseInt(key, 10);
+            return [parsedKey, recursiveParseJSON(value)];
+        }));
+    }
+    else {
+        return data;
+    }
+}
+export { Engine, sendData, ValidPermissions };

package/dist/core/inmemory.d.ts

@@ -0,0 +1,98 @@
+import GenericKV from '../classes/generic.js';
+/**
+ * InMemory class that extends GenericKV for in-memory keyspace operations.
+ * It provides methods for inserting, updating, and retrieving data in an in-memory store.
+ */
+declare class InMemory extends GenericKV {
+    static persistent: boolean;
+    static distributed: boolean;
+    /**
+     * Creates a keyspace in the in-memory store.
+     * @returns A promise that resolves with the result of the keyspace creation.
+     */
+    static createKeyspace(): Promise<any>;
+    /**
+     * Snapshots the current state of the in-memory keyspace.
+     * @returns A promise that resolves with the result of the snapshot operation.
+     */
+    static doSnapshotsForKeyspace(): Promise<any>;
+    /**
+     * Cleans up snapshots for the in-memory keyspace.
+     * @returns A promise that resolves with the result of the cleanup operation.
+     */
+    static cleanSnapshotsForKeyspace(): Promise<any>;
+    /**
+     * Stops snapshots for the in-memory keyspace.
+     * @returns A promise that resolves with the result of stopping snapshots.
+     */
+    static stopSnapshotsForKeyspace(): Promise<any>;
+    /**
+     * Inserts a value into the in-memory store.
+     * @param value - The value to insert.
+     * @param expireSec - The expiration time in seconds for the value.
+     * @return A promise that resolves with the result of the insertion.
+     * */
+    static insertValue({ value, expireSec }?: {
+        value?: any;
+        expireSec?: number;
+    }): Promise<any>;
+    /**
+     * Inserts a custom key into the in-memory store.
+     * @param customKey - The custom key for the value.
+     * @param expireSec - The expiration time in seconds for the value.
+     * @return A promise that resolves with the result of the insertion.
+     */
+    static insertCustomKey({ customKey, expireSec }: {
+        customKey: string;
+        expireSec?: number;
+    }): Promise<any>;
+    /**
+     * Inserts a custom key-value pair into the in-memory store.
+     * @param customKey - The custom key for the value.
+     * @param value - The value to insert.
+     * @param expireSec - The expiration time in seconds for the value.
+     * @return A promise that resolves with the result of the insertion.
+     */
+    static insertCustomKeyValue({ customKey, value, expireSec }: {
+        customKey: string;
+        value?: any;
+        expireSec?: number;
+    }): Promise<any>;
+    /**
+     * Updates a value in the in-memory store.
+     * @param key - The key for the value to update.
+     * @param customKey - The custom key for the value to update.
+     * @param value - The new value to set.
+     * @param expireSec - The expiration time in seconds for the value.
+     * @return A promise that resolves with the result of the update.
+     */
+    static updateValue({ key, customKey, value, expireSec }?: {
+        key?: string;
+        customKey?: string | null;
+        value?: any;
+        expireSec?: number;
+    }): Promise<any>;
+    /**
+        * Inserts a bulk of values into the in-memory store.
+        * @param bulk - An array of values to insert.
+        * @param expireSec - The expiration time in seconds for the values.
+        * @return A promise that resolves with the result of the insertion.
+     */
+    static insertBulk({ bulk, expireSec }?: {
+        bulk?: any[];
+        expireSec?: number;
+    }): Promise<any>;
+    /**
+     * Gets keys from the in-memory store.
+     * @returns A promise that resolves with the retrieved keys.
+     */
+    static getKeys(): Promise<any>;
+}
+/**
+ * InMemoryDistributed class that extends InMemory for distributed in-memory keyspace operations.
+ * It provides methods for distributed operations in an in-memory store.
+ */
+declare class InMemoryDistributed extends InMemory {
+    static distributed: boolean;
+}
+export { InMemory, InMemoryDistributed };

package/dist/core/inmemory.js

@@ -0,0 +1,150 @@
+import { runQuery, convertToBinaryQuery, convertCustomKey } from '../functions/storeGenericFunctions.js';
+import GenericKV from '../classes/generic.js';
+/**
+ * InMemory class that extends GenericKV for in-memory keyspace operations.
+ * It provides methods for inserting, updating, and retrieving data in an in-memory store.
+ */
+class InMemory extends GenericKV {
+    static persistent = false;
+    static distributed = false;
+    /**
+     * Creates a keyspace in the in-memory store.
+     * @returns A promise that resolves with the result of the keyspace creation.
+     */
+    static async createKeyspace() {
+        const query = {
+            raw: ["create-keyspace", "store", this.store, "keyspace", this.keyspace, "persistent", this.persistent ? "y" : "n"],
+            credentials: [this.username, this.password],
+        };
+        return await runQuery(this, JSON.stringify(query));
+    }
+    /**
+     * Snapshots the current state of the in-memory keyspace.
+     * @returns A promise that resolves with the result of the snapshot operation.
+     */
+    static async doSnapshotsForKeyspace() {
+        if (this.persistent) {
+            throw new Error("Snapshots are not allowed on persistent keyspaces");
+        }
+        const query = {
+            raw: ["do-snapshots-for-keyspace", "store", this.store, "keyspace", this.keyspace, "persistent", "n"],
+            credentials: [this.username, this.password],
+        };
+        return runQuery(this, JSON.stringify(query));
+    }
+    /**
+     * Cleans up snapshots for the in-memory keyspace.
+     * @returns A promise that resolves with the result of the cleanup operation.
+     */
+    static async cleanSnapshotsForKeyspace() {
+        if (this.persistent) {
+            throw new Error("Snapshots are not allowed on persistent keyspaces");
+        }
+        const query = {
+            raw: ["clean-snapshots-for-keyspace", "store", this.store, "keyspace", this.keyspace, "persistent", "n"],
+            credentials: [this.username, this.password],
+        };
+        return runQuery(this, JSON.stringify(query));
+    }
+    /**
+     * Stops snapshots for the in-memory keyspace.
+     * @returns A promise that resolves with the result of stopping snapshots.
+     */
+    static async stopSnapshotsForKeyspace() {
+        if (this.persistent) {
+            throw new Error("Snapshots are not allowed on persistent keyspaces");
+        }
+        const query = {
+            raw: ["stop-snapshots-for-keyspace", "store", this.store, "keyspace", this.keyspace, "persistent", "n"],
+            credentials: [this.username, this.password],
+        };
+        return runQuery(this, JSON.stringify(query));
+    }
+    /**
+     * Inserts a value into the in-memory store.
+     * @param value - The value to insert.
+     * @param expireSec - The expiration time in seconds for the value.
+     * @return A promise that resolves with the result of the insertion.
+     * */
+    static async insertValue({ value = {}, expireSec = 0 } = {}) {
+        this.command = "insert_value";
+        const query = convertToBinaryQuery(this, { value, expireSec });
+        return runQuery(this, query);
+    }
+    /**
+     * Inserts a custom key into the in-memory store.
+     * @param customKey - The custom key for the value.
+     * @param expireSec - The expiration time in seconds for the value.
+     * @return A promise that resolves with the result of the insertion.
+     */
+    static async insertCustomKey({ customKey, expireSec = 0 }) {
+        if (!customKey) {
+            throw new Error("No key provided");
+        }
+        this.command = "insert_custom_key";
+        const query = convertToBinaryQuery(this, { key: convertCustomKey(customKey), expireSec });
+        return runQuery(this, query);
+    }
+    /**
+     * Inserts a custom key-value pair into the in-memory store.
+     * @param customKey - The custom key for the value.
+     * @param value - The value to insert.
+     * @param expireSec - The expiration time in seconds for the value.
+     * @return A promise that resolves with the result of the insertion.
+     */
+    static async insertCustomKeyValue({ customKey, value = {}, expireSec = 0 }) {
+        this.command = "insert_custom_key_value";
+        const query = convertToBinaryQuery(this, { key: convertCustomKey(customKey), value, expireSec });
+        return runQuery(this, query);
+    }
+    /**
+     * Updates a value in the in-memory store.
+     * @param key - The key for the value to update.
+     * @param customKey - The custom key for the value to update.
+     * @param value - The new value to set.
+     * @param expireSec - The expiration time in seconds for the value.
+     * @return A promise that resolves with the result of the update.
+     */
+    static async updateValue({ key = "", customKey = null, value = {}, expireSec = 0 } = {}) {
+        const effectiveKey = customKey ? convertCustomKey(customKey) : key;
+        if (!effectiveKey) {
+            throw new Error("No key provided");
+        }
+        this.command = "update_value";
+        const query = convertToBinaryQuery(this, { key: effectiveKey, value, expireSec });
+        return runQuery(this, query);
+    }
+    /**
+        * Inserts a bulk of values into the in-memory store.
+        * @param bulk - An array of values to insert.
+        * @param expireSec - The expiration time in seconds for the values.
+        * @return A promise that resolves with the result of the insertion.
+     */
+    static async insertBulk({ bulk = [], expireSec = 0 } = {}) {
+        if (!bulk || bulk.length === 0) {
+            throw new Error("No values provided");
+        }
+        this.command = "insert_bulk";
+        const query = convertToBinaryQuery(this, { bulkValues: bulk, expireSec });
+        return runQuery(this, query);
+    }
+    /**
+     * Gets keys from the in-memory store.
+     * @returns A promise that resolves with the retrieved keys.
+     */
+    static async getKeys() {
+        this.command = "get_keys";
+        const query = convertToBinaryQuery(this);
+        return runQuery(this, query);
+    }
+}
+;
+/**
+ * InMemoryDistributed class that extends InMemory for distributed in-memory keyspace operations.
+ * It provides methods for distributed operations in an in-memory store.
+ */
+class InMemoryDistributed extends InMemory {
+    static distributed = true;
+}
+;
+export { InMemory, InMemoryDistributed };

package/dist/core/persistent.d.ts

@@ -0,0 +1,98 @@
+import GenericKV from '../classes/generic.js';
+/**
+ * Persistent class that extends GenericKV for persistent keyspace operations.
+ * It provides methods for inserting, updating, and retrieving data in a persistent store.
+ */
+declare class Persistent extends GenericKV {
+    static persistent: boolean;
+    static distributed: boolean;
+    static cache: number | null;
+    static compression: boolean;
+    keyspace: string;
+    constructor(options: {
+        keyspace: string;
+        username: string;
+        password: string;
+        [key: string]: any;
+    });
+    /**
+     * Inserts a value into the persistent store.
+     * @param value - The value to insert.
+     * @return A promise that resolves with the result of the insertion.
+     */
+    static insertValue({ value }?: {
+        value?: any;
+    }): Promise<any>;
+    /**
+     * Inserts a key-value pair into the persistent store.
+     * @param key - The key for the value.
+     * @param value - The value to insert.
+     * @return A promise that resolves with the result of the insertion.
+     */
+    static insertCustomKey({ customKey }: {
+        customKey: string;
+    }): Promise<any>;
+    /**
+     * Inserts a custom key-value pair into the persistent store.
+     * @param customKey - The custom key for the value.
+     * @param value - The value to insert.
+     * @return A promise that resolves with the result of the insertion.
+     */
+    static insertCustomKeyValue({ customKey, value }: {
+        customKey: string;
+        value?: any;
+    }): Promise<any>;
+    /**
+     * Updates a value in the persistent store.
+     * @param key - The key for the value to update.
+     * @param customKey - The custom key for the value to update.
+     * @param value - The new value to set.
+     * @return A promise that resolves with the result of the update.
+     */
+    static updateValue({ key, customKey, value }?: {
+        key?: string;
+        customKey?: string | null;
+        value?: any;
+    }): Promise<any>;
+    /**
+     * Retrieves a value from the persistent store.
+     * @param key - The key for the value to retrieve.
+     * @param customKey - The custom key for the value to retrieve.
+     * @return A promise that resolves with the retrieved value.
+     */
+    static insertBulk({ bulk }?: {
+        bulk?: any[];
+    }): Promise<any>;
+    /**
+     * Retrieves a value from the persistent store.
+     * @param key - The key for the value to retrieve.
+     * @param customKey - The custom key for the value to retrieve.
+     * @return A promise that resolves with the retrieved value.
+     */
+    static getKeys({ limitOutput }?: {
+        limitOutput?: {
+            start: number;
+            stop: number;
+        };
+    }): 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.
+     * @return A promise that resolves with the result of the update.
+     */
+    static updateCacheAndCompression(): Promise<any>;
+    /**
+     * Creates a keyspace in the persistent store.
+     * @return A promise that resolves with the result of the keyspace creation.
+     */
+    static createKeyspace(): Promise<any>;
+}
+/**
+ * PersistentDistributed class that extends Persistent for distributed persistent keyspace operations.
+ * It provides methods for distributed operations in a persistent store.
+ */
+declare class PersistentDistributed extends Persistent {
+    static distributed: boolean;
+}
+export { Persistent, PersistentDistributed };