@optimizely/ocp-local-env 1.0.0-beta.4

package/dist/src/local_engine/storage/LocalKVStore.js

@@ -0,0 +1,1002 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalKVStore = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const NumberSet_1 = require("./NumberSet");
+const StringSet_1 = require("./StringSet");
+/**
+ * Local implementation of KVStore that persists data to disk
+ * Follows the pattern of LocalSettingsStore with singleton per app directory
+ */
+class LocalKVStore {
+    constructor(appRootDir, storeFileName = "kvstore.json") {
+        this.appRootDir = appRootDir;
+        this.storeFileName = storeFileName;
+        this.configDirPath = path_1.default.join(appRootDir, ".ocp-local");
+        this.kvStorePath = path_1.default.join(this.configDirPath, storeFileName);
+        // Initialize store file if it doesn't exist
+        this.ensureStoreFileExists();
+    }
+    /**
+     * Get or create a singleton instance for the given app directory
+     */
+    static getInstance(appRootDir, storeFileName) {
+        const normalizedPath = path_1.default.resolve(appRootDir);
+        const instanceKey = `${normalizedPath}:${storeFileName || "kvstore.json"}`;
+        if (!this.instances.has(instanceKey)) {
+            this.instances.set(instanceKey, new LocalKVStore(normalizedPath, storeFileName));
+        }
+        return this.instances.get(instanceKey);
+    }
+    /**
+     * Clear singleton instance for testing
+     */
+    static clearInstance(appRootDir, storeFileName) {
+        const normalizedPath = path_1.default.resolve(appRootDir);
+        const instanceKey = `${normalizedPath}:${storeFileName || "kvstore.json"}`;
+        this.instances.delete(instanceKey);
+    }
+    /**
+     * Clear all singleton instances for testing
+     */
+    static clearAllInstances() {
+        this.instances.clear();
+    }
+    /**
+     * Ensure store file exists with empty structure
+     */
+    ensureStoreFileExists() {
+        try {
+            // Ensure the .ocp-local directory exists
+            if (!fs_1.default.existsSync(this.configDirPath)) {
+                fs_1.default.mkdirSync(this.configDirPath, { recursive: true });
+            }
+            // Create empty store file if it doesn't exist
+            if (!fs_1.default.existsSync(this.kvStorePath)) {
+                this.saveDataToDisk({});
+            }
+        }
+        catch (error) {
+            console.warn(`Failed to ensure KV store file exists at ${this.kvStorePath}:`, error);
+        }
+    }
+    /**
+     * Load data from disk and clean up expired entries
+     */
+    loadDataFromDisk() {
+        try {
+            if (!fs_1.default.existsSync(this.kvStorePath)) {
+                return {};
+            }
+            const storeData = fs_1.default.readFileSync(this.kvStorePath, "utf-8");
+            const data = JSON.parse(storeData);
+            // Clean up expired entries
+            const now = Date.now();
+            const cleanedData = {};
+            for (const [key, item] of Object.entries(data)) {
+                if (!item.expiresAt || item.expiresAt > now) {
+                    cleanedData[key] = item;
+                }
+            }
+            // Save cleaned data if any entries were removed
+            if (Object.keys(cleanedData).length !== Object.keys(data).length) {
+                this.saveDataToDisk(cleanedData);
+            }
+            return cleanedData;
+        }
+        catch (error) {
+            console.warn(`Failed to load KV store from ${this.kvStorePath}:`, error);
+            return {};
+        }
+    }
+    /**
+     * Save data to disk atomically
+     */
+    saveDataToDisk(data) {
+        try {
+            // Ensure the .ocp-local directory exists
+            if (!fs_1.default.existsSync(this.configDirPath)) {
+                fs_1.default.mkdirSync(this.configDirPath, { recursive: true });
+            }
+            // Serialize data with custom handling for NumberSet and StringSet
+            const serializedData = JSON.stringify(data, (key, value) => {
+                if (value instanceof NumberSet_1.NumberSet) {
+                    return { _type: "NumberSet", values: Array.from(value) };
+                }
+                if (value instanceof StringSet_1.StringSet) {
+                    return { _type: "StringSet", values: Array.from(value) };
+                }
+                return value;
+            }, 2);
+            // Write to temp file first, then rename for atomicity
+            const tempPath = `${this.kvStorePath}.tmp`;
+            fs_1.default.writeFileSync(tempPath, serializedData, "utf-8");
+            fs_1.default.renameSync(tempPath, this.kvStorePath);
+        }
+        catch (error) {
+            console.error(`Failed to save KV store to ${this.kvStorePath}:`, error);
+            throw error;
+        }
+    }
+    /**
+     * Deserialize data with custom handling for NumberSet and StringSet
+     */
+    deserializeValue(value) {
+        if (value && typeof value === "object" && value._type) {
+            switch (value._type) {
+                case "NumberSet":
+                    return new NumberSet_1.NumberSet(value.values);
+                case "StringSet":
+                    return new StringSet_1.StringSet(value.values);
+            }
+        }
+        if (Array.isArray(value)) {
+            return value.map((item) => this.deserializeValue(item));
+        }
+        if (value && typeof value === "object") {
+            const result = {};
+            for (const [k, v] of Object.entries(value)) {
+                result[k] = this.deserializeValue(v);
+            }
+            return result;
+        }
+        return value;
+    }
+    /**
+     * Get stored item with deserialization
+     */
+    getStoredItem(key) {
+        const data = this.loadDataFromDisk();
+        const item = data[key];
+        if (!item) {
+            return null;
+        }
+        // Deserialize the data
+        const deserializedData = this.deserializeValue(item.data);
+        return {
+            ...item,
+            data: deserializedData,
+        };
+    }
+    /**
+     * Store item with optional TTL
+     */
+    storeItem(key, data, options) {
+        const storeData = this.loadDataFromDisk();
+        const item = { data };
+        if (options?.ttl !== undefined) {
+            item.ttl = options.ttl;
+            item.expiresAt = Date.now() + options.ttl * 1000;
+        }
+        storeData[key] = item;
+        this.saveDataToDisk(storeData);
+    }
+    // ===================================================================================================================
+    // Basic Operations
+    // ===================================================================================================================
+    async get(key, fields) {
+        console.log(`[LocalKVStore] GET request: key="${key}", fields=${JSON.stringify(fields)}`);
+        try {
+            const item = this.getStoredItem(key);
+            if (!item) {
+                console.log(`[LocalKVStore] GET result: key="${key}" -> {}`);
+                return {};
+            }
+            if (fields && fields.length > 0) {
+                // Return only requested fields
+                const filteredData = {};
+                fields.forEach((field) => {
+                    if (item.data[field] !== undefined) {
+                        filteredData[field] = item.data[field];
+                    }
+                });
+                console.log(`[LocalKVStore] GET result: key="${key}" -> ${JSON.stringify(filteredData)}`);
+                return filteredData;
+            }
+            else {
+                // Return all data
+                console.log(`[LocalKVStore] GET result: key="${key}" -> ${JSON.stringify(item.data)}`);
+                return item.data;
+            }
+        }
+        catch (error) {
+            console.warn(`[LocalKVStore] GET failed: key="${key}":`, error);
+            return {};
+        }
+    }
+    async put(key, value, options) {
+        console.log(`[LocalKVStore] PUT request: key="${key}", value=${JSON.stringify(value)}`);
+        try {
+            // Get previous value
+            const previousItem = this.getStoredItem(key);
+            const previousValue = previousItem ? previousItem.data : {};
+            // Store new value
+            this.storeItem(key, value, options);
+            console.log(`[LocalKVStore] PUT completed: key="${key}"`);
+            return previousValue;
+        }
+        catch (error) {
+            console.warn(`[LocalKVStore] PUT failed: key="${key}":`, error);
+            throw error;
+        }
+    }
+    async patch(key, valueOrUpdater, options) {
+        console.log(`[LocalKVStore] PATCH request: key="${key}"`);
+        try {
+            // Get current value
+            const currentItem = this.getStoredItem(key);
+            const currentValue = currentItem ? currentItem.data : {};
+            let newValue;
+            if (typeof valueOrUpdater === "function") {
+                // Updater function
+                const updater = valueOrUpdater;
+                try {
+                    // Try with options first (KVPatchUpdaterWithOptions)
+                    const currentOptions = { ttl: currentItem?.ttl };
+                    newValue = updater(currentValue, currentOptions);
+                }
+                catch (error) {
+                    // Fall back to regular PatchUpdater
+                    newValue = updater(currentValue);
+                }
+            }
+            else {
+                // Value object - merge with current
+                newValue = { ...currentValue, ...valueOrUpdater };
+            }
+            // Store updated value
+            this.storeItem(key, newValue, options);
+            console.log(`[LocalKVStore] PATCH completed: key="${key}"`);
+            return currentValue;
+        }
+        catch (error) {
+            console.warn(`[LocalKVStore] PATCH failed: key="${key}":`, error);
+            throw error;
+        }
+    }
+    async delete(key, fields) {
+        console.log(`[LocalKVStore] DELETE request: key="${key}", fields=${JSON.stringify(fields)}`);
+        try {
+            const storeData = this.loadDataFromDisk();
+            const item = storeData[key];
+            if (!item) {
+                console.log(`[LocalKVStore] DELETE result: key="${key}" -> {} (not found)`);
+                return {};
+            }
+            const deserializedData = this.deserializeValue(item.data);
+            if (!fields || fields.length === 0) {
+                // Delete entire object
+                delete storeData[key];
+                this.saveDataToDisk(storeData);
+                console.log(`[LocalKVStore] DELETE completed: deleted entire key="${key}"`);
+                return deserializedData;
+            }
+            else {
+                // Delete specific fields
+                const deletedFields = {};
+                fields.forEach((field) => {
+                    if (item.data[field] !== undefined) {
+                        deletedFields[field] = item.data[field];
+                        delete item.data[field];
+                    }
+                });
+                this.saveDataToDisk(storeData);
+                console.log(`[LocalKVStore] DELETE completed: deleted fields ${JSON.stringify(fields)} from key="${key}"`);
+                return this.deserializeValue(deletedFields);
+            }
+        }
+        catch (error) {
+            console.warn(`[LocalKVStore] DELETE failed: key="${key}":`, error);
+            throw error;
+        }
+    }
+    async exists(key) {
+        console.log(`[LocalKVStore] EXISTS request: key="${key}"`);
+        try {
+            const item = this.getStoredItem(key);
+            const exists = item !== null;
+            console.log(`[LocalKVStore] EXISTS result: key="${key}" -> ${exists}`);
+            return exists;
+        }
+        catch (error) {
+            console.warn(`[LocalKVStore] EXISTS failed: key="${key}":`, error);
+            return false;
+        }
+    }
+    // ===================================================================================================================
+    // Numeric Operations
+    // ===================================================================================================================
+    async increment(key, field, amount = 1, options) {
+        console.log(`[LocalKVStore] INCREMENT request: key="${key}", field="${field}", amount=${amount}`);
+        return this.patch(key, (previous) => {
+            const currentValue = previous[field];
+            if (currentValue !== undefined && typeof currentValue !== "number") {
+                throw new Error(`Field "${field}" is not a number`);
+            }
+            const newValue = (currentValue || 0) + amount;
+            return {
+                ...previous,
+                [field]: newValue,
+            };
+        }, options).then(() => {
+            // Return the new value
+            return this.get(key, [field]).then((result) => result[field]);
+        });
+    }
+    async incrementMulti(key, fieldAmounts, options) {
+        console.log(`[LocalKVStore] INCREMENT_MULTI request: key="${key}", fieldAmounts=${JSON.stringify(fieldAmounts)}`);
+        return this.patch(key, (previous) => {
+            const updated = { ...previous };
+            for (const [field, amount] of Object.entries(fieldAmounts)) {
+                const currentValue = updated[field];
+                if (currentValue !== undefined && typeof currentValue !== "number") {
+                    throw new Error(`Field "${field}" is not a number`);
+                }
+                updated[field] = (currentValue || 0) + amount;
+            }
+            return updated;
+        }, options).then(() => {
+            // Return the new values
+            return this.get(key, Object.keys(fieldAmounts)).then((result) => {
+                const newValues = {};
+                for (const field of Object.keys(fieldAmounts)) {
+                    newValues[field] = result[field];
+                }
+                return newValues;
+            });
+        });
+    }
+    // ===================================================================================================================
+    // List Operations
+    // ===================================================================================================================
+    async shift(key, field) {
+        console.log(`[LocalKVStore] SHIFT request: key="${key}", field="${field}"`);
+        let shiftedElement = undefined;
+        await this.patch(key, (previous) => {
+            const currentValue = previous[field];
+            if (currentValue === undefined) {
+                return previous;
+            }
+            if (!Array.isArray(currentValue)) {
+                throw new Error(`Field "${field}" is not a list`);
+            }
+            if (currentValue.length === 0) {
+                return previous;
+            }
+            // Capture the first element before removing it
+            shiftedElement = currentValue[0];
+            // Remove first element
+            const updatedList = [...currentValue.slice(1)];
+            return {
+                ...previous,
+                [field]: updatedList,
+            };
+        });
+        console.log(`[LocalKVStore] SHIFT result: key="${key}", field="${field}" -> ${JSON.stringify(shiftedElement)}`);
+        return shiftedElement;
+    }
+    async shiftMulti(key, fieldCounts) {
+        console.log(`[LocalKVStore] SHIFT_MULTI request: key="${key}", fieldCounts=${JSON.stringify(fieldCounts)}`);
+        const shiftedItems = {};
+        return this.patch(key, (previous) => {
+            const updated = { ...previous };
+            for (const [field, count] of Object.entries(fieldCounts)) {
+                const currentValue = updated[field];
+                if (currentValue === undefined) {
+                    shiftedItems[field] = [];
+                    continue;
+                }
+                if (!Array.isArray(currentValue)) {
+                    throw new Error(`Field "${field}" is not a list`);
+                }
+                const actualCount = Math.min(count, currentValue.length);
+                shiftedItems[field] = currentValue.slice(0, actualCount);
+                updated[field] = currentValue.slice(actualCount);
+            }
+            return updated;
+        }).then(() => shiftedItems);
+    }
+    async unshift(key, field, value) {
+        console.log(`[LocalKVStore] UNSHIFT request: key="${key}", field="${field}", value=${JSON.stringify(value)}`);
+        await this.patch(key, (previous) => {
+            const currentValue = previous[field];
+            if (currentValue === undefined) {
+                // Create new list with the value
+                return {
+                    ...previous,
+                    [field]: [value],
+                };
+            }
+            if (!Array.isArray(currentValue)) {
+                throw new Error(`Field "${field}" is not a list`);
+            }
+            // Prepend to existing list
+            return {
+                ...previous,
+                [field]: [value, ...currentValue],
+            };
+        });
+    }
+    async unshiftMulti(key, fieldValues) {
+        console.log(`[LocalKVStore] UNSHIFT_MULTI request: key="${key}", fieldValues=${JSON.stringify(fieldValues)}`);
+        await this.patch(key, (previous) => {
+            const updated = { ...previous };
+            for (const [field, values] of Object.entries(fieldValues)) {
+                const currentValue = updated[field];
+                if (currentValue === undefined) {
+                    // Create new list with the values
+                    updated[field] = [...values];
+                }
+                else {
+                    if (!Array.isArray(currentValue)) {
+                        throw new Error(`Field "${field}" is not a list`);
+                    }
+                    // Prepend to existing list
+                    updated[field] = [...values, ...currentValue];
+                }
+            }
+            return updated;
+        });
+    }
+    async peek(key, field) {
+        console.log(`[LocalKVStore] PEEK request: key="${key}", field="${field}"`);
+        try {
+            const item = this.getStoredItem(key);
+            if (!item) {
+                console.log(`[LocalKVStore] PEEK result: key="${key}" -> undefined (key not found)`);
+                return undefined;
+            }
+            const fieldValue = item.data[field];
+            if (fieldValue === undefined) {
+                console.log(`[LocalKVStore] PEEK result: key="${key}", field="${field}" -> undefined (field not found)`);
+                return undefined;
+            }
+            if (!Array.isArray(fieldValue)) {
+                console.log(`[LocalKVStore] PEEK result: key="${key}", field="${field}" -> undefined (not a list)`);
+                return undefined;
+            }
+            if (fieldValue.length === 0) {
+                console.log(`[LocalKVStore] PEEK result: key="${key}", field="${field}" -> undefined (empty list)`);
+                return undefined;
+            }
+            const firstElement = fieldValue[0];
+            console.log(`[LocalKVStore] PEEK result: key="${key}", field="${field}" -> ${JSON.stringify(firstElement)}`);
+            return firstElement;
+        }
+        catch (error) {
+            console.warn(`[LocalKVStore] PEEK failed: key="${key}", field="${field}":`, error);
+            return undefined;
+        }
+    }
+    async peekMulti(key, fieldCounts) {
+        console.log(`[LocalKVStore] PEEK_MULTI request: key="${key}", fieldCounts=${JSON.stringify(fieldCounts)}`);
+        const result = {};
+        try {
+            const item = this.getStoredItem(key);
+            if (!item) {
+                // Return empty arrays for all fields
+                for (const field of Object.keys(fieldCounts)) {
+                    result[field] = [];
+                }
+                return result;
+            }
+            for (const [field, count] of Object.entries(fieldCounts)) {
+                const fieldValue = item.data[field];
+                if (fieldValue === undefined || !Array.isArray(fieldValue)) {
+                    result[field] = [];
+                    continue;
+                }
+                const actualCount = Math.min(count, fieldValue.length);
+                result[field] = fieldValue.slice(0, actualCount);
+            }
+            console.log(`[LocalKVStore] PEEK_MULTI result: key="${key}" -> ${JSON.stringify(result)}`);
+            return result;
+        }
+        catch (error) {
+            console.warn(`[LocalKVStore] PEEK_MULTI failed: key="${key}":`, error);
+            // Return empty arrays for all fields on error
+            for (const field of Object.keys(fieldCounts)) {
+                result[field] = [];
+            }
+            return result;
+        }
+    }
+    async append(key, field, value) {
+        console.log(`[LocalKVStore] APPEND request: key="${key}", field="${field}", value=${JSON.stringify(value)}`);
+        await this.patch(key, (previous) => {
+            const currentValue = previous[field];
+            if (currentValue === undefined) {
+                // Create new list with the value
+                return {
+                    ...previous,
+                    [field]: [value],
+                };
+            }
+            if (!Array.isArray(currentValue)) {
+                throw new Error(`Field "${field}" is not a list`);
+            }
+            // Append to existing list
+            return {
+                ...previous,
+                [field]: [...currentValue, value],
+            };
+        });
+    }
+    async appendMulti(key, fieldValues) {
+        console.log(`[LocalKVStore] APPEND_MULTI request: key="${key}", fieldValues=${JSON.stringify(fieldValues)}`);
+        await this.patch(key, (previous) => {
+            const updated = { ...previous };
+            for (const [field, values] of Object.entries(fieldValues)) {
+                const currentValue = updated[field];
+                if (currentValue === undefined) {
+                    // Create new list with the values
+                    updated[field] = [...values];
+                }
+                else {
+                    if (!Array.isArray(currentValue)) {
+                        throw new Error(`Field "${field}" is not a list`);
+                    }
+                    // Append to existing list
+                    updated[field] = [...currentValue, ...values];
+                }
+            }
+            return updated;
+        });
+    }
+    // ===================================================================================================================
+    // NumberSet Operations
+    // ===================================================================================================================
+    async addNumber(key, field, value) {
+        console.log(`[LocalKVStore] ADD_NUMBER request: key="${key}", field="${field}", value=${value}`);
+        let wasAdded = false;
+        await this.patch(key, (previous) => {
+            const currentValue = previous[field];
+            if (currentValue === undefined) {
+                // Create new NumberSet with the value
+                const newSet = new NumberSet_1.NumberSet([value]);
+                wasAdded = true;
+                return {
+                    ...previous,
+                    [field]: newSet,
+                };
+            }
+            if (!(currentValue instanceof NumberSet_1.NumberSet)) {
+                throw new Error(`Field "${field}" is not a NumberSet`);
+            }
+            // Check if value already exists
+            wasAdded = !currentValue.has(value);
+            if (wasAdded) {
+                // Create new NumberSet with added value
+                const newSet = new NumberSet_1.NumberSet(currentValue);
+                newSet.add(value);
+                return {
+                    ...previous,
+                    [field]: newSet,
+                };
+            }
+            return previous;
+        });
+        console.log(`[LocalKVStore] ADD_NUMBER result: key="${key}", field="${field}" -> ${wasAdded}`);
+        return wasAdded;
+    }
+    async addNumberMulti(key, fieldValues) {
+        console.log(`[LocalKVStore] ADD_NUMBER_MULTI request: key="${key}", fieldValues=${JSON.stringify(fieldValues)}`);
+        const addedValues = {};
+        await this.patch(key, (previous) => {
+            const updated = { ...previous };
+            for (const [field, values] of Object.entries(fieldValues)) {
+                const currentValue = updated[field];
+                const newlyAdded = new NumberSet_1.NumberSet();
+                if (currentValue === undefined) {
+                    // Create new NumberSet with all values
+                    const newSet = new NumberSet_1.NumberSet(values);
+                    updated[field] = newSet;
+                    addedValues[field] = new NumberSet_1.NumberSet(values);
+                }
+                else {
+                    if (!(currentValue instanceof NumberSet_1.NumberSet)) {
+                        throw new Error(`Field "${field}" is not a NumberSet`);
+                    }
+                    // Create new NumberSet and track newly added values
+                    const newSet = new NumberSet_1.NumberSet(currentValue);
+                    for (const value of values) {
+                        if (!newSet.has(value)) {
+                            newSet.add(value);
+                            newlyAdded.add(value);
+                        }
+                    }
+                    updated[field] = newSet;
+                    addedValues[field] = newlyAdded;
+                }
+            }
+            return updated;
+        });
+        console.log(`[LocalKVStore] ADD_NUMBER_MULTI result: key="${key}" -> ${JSON.stringify(addedValues)}`);
+        return addedValues;
+    }
+    async removeNumber(key, field, value) {
+        console.log(`[LocalKVStore] REMOVE_NUMBER request: key="${key}", field="${field}", value=${value}`);
+        let wasRemoved = false;
+        await this.patch(key, (previous) => {
+            const currentValue = previous[field];
+            if (currentValue === undefined) {
+                return previous;
+            }
+            if (!(currentValue instanceof NumberSet_1.NumberSet)) {
+                throw new Error(`Field "${field}" is not a NumberSet`);
+            }
+            // Check if value exists
+            wasRemoved = currentValue.has(value);
+            if (wasRemoved) {
+                // Create new NumberSet with removed value
+                const newSet = new NumberSet_1.NumberSet(currentValue);
+                newSet.delete(value);
+                return {
+                    ...previous,
+                    [field]: newSet,
+                };
+            }
+            return previous;
+        });
+        console.log(`[LocalKVStore] REMOVE_NUMBER result: key="${key}", field="${field}" -> ${wasRemoved}`);
+        return wasRemoved;
+    }
+    async removeNumberMulti(key, fieldValues) {
+        console.log(`[LocalKVStore] REMOVE_NUMBER_MULTI request: key="${key}", fieldValues=${JSON.stringify(fieldValues)}`);
+        const removedValues = {};
+        await this.patch(key, (previous) => {
+            const updated = { ...previous };
+            for (const [field, values] of Object.entries(fieldValues)) {
+                const currentValue = updated[field];
+                const actuallyRemoved = new NumberSet_1.NumberSet();
+                if (currentValue === undefined) {
+                    removedValues[field] = actuallyRemoved;
+                    continue;
+                }
+                if (!(currentValue instanceof NumberSet_1.NumberSet)) {
+                    throw new Error(`Field "${field}" is not a NumberSet`);
+                }
+                // Create new NumberSet and track removed values
+                const newSet = new NumberSet_1.NumberSet(currentValue);
+                for (const value of values) {
+                    if (newSet.has(value)) {
+                        newSet.delete(value);
+                        actuallyRemoved.add(value);
+                    }
+                }
+                updated[field] = newSet;
+                removedValues[field] = actuallyRemoved;
+            }
+            return updated;
+        });
+        console.log(`[LocalKVStore] REMOVE_NUMBER_MULTI result: key="${key}" -> ${JSON.stringify(removedValues)}`);
+        return removedValues;
+    }
+    async hasNumber(key, field, value) {
+        console.log(`[LocalKVStore] HAS_NUMBER request: key="${key}", field="${field}", value=${value}`);
+        try {
+            const item = this.getStoredItem(key);
+            if (!item) {
+                console.log(`[LocalKVStore] HAS_NUMBER result: key="${key}" -> false (key not found)`);
+                return false;
+            }
+            const fieldValue = item.data[field];
+            if (fieldValue === undefined) {
+                console.log(`[LocalKVStore] HAS_NUMBER result: key="${key}", field="${field}" -> false (field not found)`);
+                return false;
+            }
+            if (!(fieldValue instanceof NumberSet_1.NumberSet)) {
+                throw new Error(`Field "${field}" is not a NumberSet`);
+            }
+            const hasValue = fieldValue.has(value);
+            console.log(`[LocalKVStore] HAS_NUMBER result: key="${key}", field="${field}" -> ${hasValue}`);
+            return hasValue;
+        }
+        catch (error) {
+            console.warn(`[LocalKVStore] HAS_NUMBER failed: key="${key}", field="${field}":`, error);
+            throw error;
+        }
+    }
+    async hasNumberMulti(key, fieldValues) {
+        console.log(`[LocalKVStore] HAS_NUMBER_MULTI request: key="${key}", fieldValues=${JSON.stringify(fieldValues)}`);
+        const result = {};
+        try {
+            const item = this.getStoredItem(key);
+            if (!item) {
+                // Return empty NumberSets for all fields
+                for (const field of Object.keys(fieldValues)) {
+                    result[field] = new NumberSet_1.NumberSet();
+                }
+                return result;
+            }
+            for (const [field, values] of Object.entries(fieldValues)) {
+                const fieldValue = item.data[field];
+                const existingValues = new NumberSet_1.NumberSet();
+                if (fieldValue === undefined) {
+                    result[field] = existingValues;
+                    continue;
+                }
+                if (!(fieldValue instanceof NumberSet_1.NumberSet)) {
+                    throw new Error(`Field "${field}" is not a NumberSet`);
+                }
+                // Check which values exist
+                for (const value of values) {
+                    if (fieldValue.has(value)) {
+                        existingValues.add(value);
+                    }
+                }
+                result[field] = existingValues;
+            }
+            console.log(`[LocalKVStore] HAS_NUMBER_MULTI result: key="${key}" -> ${JSON.stringify(result)}`);
+            return result;
+        }
+        catch (error) {
+            console.warn(`[LocalKVStore] HAS_NUMBER_MULTI failed: key="${key}":`, error);
+            throw error;
+        }
+    }
+    // ===================================================================================================================
+    // StringSet Operations
+    // ===================================================================================================================
+    async addString(key, field, value) {
+        console.log(`[LocalKVStore] ADD_STRING request: key="${key}", field="${field}", value="${value}"`);
+        let wasAdded = false;
+        await this.patch(key, (previous) => {
+            const currentValue = previous[field];
+            if (currentValue === undefined) {
+                // Create new StringSet with the value
+                const newSet = new StringSet_1.StringSet([value]);
+                wasAdded = true;
+                return {
+                    ...previous,
+                    [field]: newSet,
+                };
+            }
+            if (!(currentValue instanceof StringSet_1.StringSet)) {
+                throw new Error(`Field "${field}" is not a StringSet`);
+            }
+            // Check if value already exists
+            wasAdded = !currentValue.has(value);
+            if (wasAdded) {
+                // Create new StringSet with added value
+                const newSet = new StringSet_1.StringSet(currentValue);
+                newSet.add(value);
+                return {
+                    ...previous,
+                    [field]: newSet,
+                };
+            }
+            return previous;
+        });
+        console.log(`[LocalKVStore] ADD_STRING result: key="${key}", field="${field}" -> ${wasAdded}`);
+        return wasAdded;
+    }
+    async addStringMulti(key, fieldValues) {
+        console.log(`[LocalKVStore] ADD_STRING_MULTI request: key="${key}", fieldValues=${JSON.stringify(fieldValues)}`);
+        const addedValues = {};
+        await this.patch(key, (previous) => {
+            const updated = { ...previous };
+            for (const [field, values] of Object.entries(fieldValues)) {
+                const currentValue = updated[field];
+                const newlyAdded = new StringSet_1.StringSet();
+                if (currentValue === undefined) {
+                    // Create new StringSet with all values
+                    const newSet = new StringSet_1.StringSet(values);
+                    updated[field] = newSet;
+                    addedValues[field] = new StringSet_1.StringSet(values);
+                }
+                else {
+                    if (!(currentValue instanceof StringSet_1.StringSet)) {
+                        throw new Error(`Field "${field}" is not a StringSet`);
+                    }
+                    // Create new StringSet and track newly added values
+                    const newSet = new StringSet_1.StringSet(currentValue);
+                    for (const value of values) {
+                        if (!newSet.has(value)) {
+                            newSet.add(value);
+                            newlyAdded.add(value);
+                        }
+                    }
+                    updated[field] = newSet;
+                    addedValues[field] = newlyAdded;
+                }
+            }
+            return updated;
+        });
+        console.log(`[LocalKVStore] ADD_STRING_MULTI result: key="${key}" -> ${JSON.stringify(addedValues)}`);
+        return addedValues;
+    }
+    async removeString(key, field, value) {
+        console.log(`[LocalKVStore] REMOVE_STRING request: key="${key}", field="${field}", value="${value}"`);
+        let wasRemoved = false;
+        await this.patch(key, (previous) => {
+            const currentValue = previous[field];
+            if (currentValue === undefined) {
+                return previous;
+            }
+            if (!(currentValue instanceof StringSet_1.StringSet)) {
+                throw new Error(`Field "${field}" is not a StringSet`);
+            }
+            // Check if value exists
+            wasRemoved = currentValue.has(value);
+            if (wasRemoved) {
+                // Create new StringSet with removed value
+                const newSet = new StringSet_1.StringSet(currentValue);
+                newSet.delete(value);
+                return {
+                    ...previous,
+                    [field]: newSet,
+                };
+            }
+            return previous;
+        });
+        console.log(`[LocalKVStore] REMOVE_STRING result: key="${key}", field="${field}" -> ${wasRemoved}`);
+        return wasRemoved;
+    }
+    async removeStringMulti(key, fieldValues) {
+        console.log(`[LocalKVStore] REMOVE_STRING_MULTI request: key="${key}", fieldValues=${JSON.stringify(fieldValues)}`);
+        const removedValues = {};
+        await this.patch(key, (previous) => {
+            const updated = { ...previous };
+            for (const [field, values] of Object.entries(fieldValues)) {
+                const currentValue = updated[field];
+                const actuallyRemoved = new StringSet_1.StringSet();
+                if (currentValue === undefined) {
+                    removedValues[field] = actuallyRemoved;
+                    continue;
+                }
+                if (!(currentValue instanceof StringSet_1.StringSet)) {
+                    throw new Error(`Field "${field}" is not a StringSet`);
+                }
+                // Create new StringSet and track removed values
+                const newSet = new StringSet_1.StringSet(currentValue);
+                for (const value of values) {
+                    if (newSet.has(value)) {
+                        newSet.delete(value);
+                        actuallyRemoved.add(value);
+                    }
+                }
+                updated[field] = newSet;
+                removedValues[field] = actuallyRemoved;
+            }
+            return updated;
+        });
+        console.log(`[LocalKVStore] REMOVE_STRING_MULTI result: key="${key}" -> ${JSON.stringify(removedValues)}`);
+        return removedValues;
+    }
+    async hasString(key, field, value) {
+        console.log(`[LocalKVStore] HAS_STRING request: key="${key}", field="${field}", value="${value}"`);
+        try {
+            const item = this.getStoredItem(key);
+            if (!item) {
+                console.log(`[LocalKVStore] HAS_STRING result: key="${key}" -> false (key not found)`);
+                return false;
+            }
+            const fieldValue = item.data[field];
+            if (fieldValue === undefined) {
+                console.log(`[LocalKVStore] HAS_STRING result: key="${key}", field="${field}" -> false (field not found)`);
+                return false;
+            }
+            if (!(fieldValue instanceof StringSet_1.StringSet)) {
+                throw new Error(`Field "${field}" is not a StringSet`);
+            }
+            const hasValue = fieldValue.has(value);
+            console.log(`[LocalKVStore] HAS_STRING result: key="${key}", field="${field}" -> ${hasValue}`);
+            return hasValue;
+        }
+        catch (error) {
+            console.warn(`[LocalKVStore] HAS_STRING failed: key="${key}", field="${field}":`, error);
+            throw error;
+        }
+    }
+    async hasStringMulti(key, fieldValues) {
+        console.log(`[LocalKVStore] HAS_STRING_MULTI request: key="${key}", fieldValues=${JSON.stringify(fieldValues)}`);
+        const result = {};
+        try {
+            const item = this.getStoredItem(key);
+            if (!item) {
+                // Return empty StringSets for all fields
+                for (const field of Object.keys(fieldValues)) {
+                    result[field] = new StringSet_1.StringSet();
+                }
+                return result;
+            }
+            for (const [field, values] of Object.entries(fieldValues)) {
+                const fieldValue = item.data[field];
+                const existingValues = new StringSet_1.StringSet();
+                if (fieldValue === undefined) {
+                    result[field] = existingValues;
+                    continue;
+                }
+                if (!(fieldValue instanceof StringSet_1.StringSet)) {
+                    throw new Error(`Field "${field}" is not a StringSet`);
+                }
+                // Check which values exist
+                for (const value of values) {
+                    if (fieldValue.has(value)) {
+                        existingValues.add(value);
+                    }
+                }
+                result[field] = existingValues;
+            }
+            console.log(`[LocalKVStore] HAS_STRING_MULTI result: key="${key}" -> ${JSON.stringify(result)}`);
+            return result;
+        }
+        catch (error) {
+            console.warn(`[LocalKVStore] HAS_STRING_MULTI failed: key="${key}":`, error);
+            throw error;
+        }
+    }
+    // ===================================================================================================================
+    // Helper Methods for API
+    // ===================================================================================================================
+    /**
+     * Get all stored data as a simple key-value object for the UI
+     */
+    getAllData() {
+        try {
+            const storeData = this.loadDataFromDisk();
+            const result = {};
+            for (const [key, item] of Object.entries(storeData)) {
+                result[key] = this.deserializeValue(item.data);
+            }
+            return result;
+        }
+        catch (error) {
+            console.warn("Failed to get all KV data:", error);
+            return {};
+        }
+    }
+    /**
+     * Set a simple key-value pair (for UI convenience)
+     */
+    async set(key, value) {
+        await this.put(key, value);
+    }
+    /**
+     * Get a simple value by key (for UI convenience)
+     */
+    async getValue(key) {
+        const result = await this.get(key);
+        return result.value;
+    }
+    /**
+     * Delete a key entirely (for UI convenience)
+     */
+    async deleteKey(key) {
+        const storeData = this.loadDataFromDisk();
+        if (key in storeData) {
+            delete storeData[key];
+            this.saveDataToDisk(storeData);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Get all keys
+     */
+    getAllKeys() {
+        try {
+            const storeData = this.loadDataFromDisk();
+            return Object.keys(storeData);
+        }
+        catch (error) {
+            console.warn("Failed to get all KV keys:", error);
+            return [];
+        }
+    }
+    /**
+     * Get a shared instance for shared KV store (global across installations of the same app)
+     */
+    static getSharedInstance(appRootDir) {
+        // Use the same app directory but with a different filename for shared storage
+        return LocalKVStore.getInstance(appRootDir, "shared-kvstore.json");
+    }
+}
+exports.LocalKVStore = LocalKVStore;
+LocalKVStore.instances = new Map();
+//# sourceMappingURL=LocalKVStore.js.map