inray 0.0.2 → 0.0.4

package/dist/caching/src/keyValue/index.js

@@ -0,0 +1,796 @@
+/**
+ * Original library: keyv (v5.6.0)
+ * - Copyright (c) 2017-2021 Luke Childs
+ * - Copyright (c) 2021-2022 Jared Wray
+ *
+ * Modified and integrated in "Inray":
+ * - Evgeniy Bushin
+ */
+/***/
+import { defaultDeserialize, defaultSerialize } from "./serialize/serialize.js";
+import EventManager from './event-manager.js';
+import HooksManager from './hooks-manager.js';
+import StatsManager from './stats-manager.js';
+const iterableAdapters = ['sqlite', 'postgres', 'mysql', 'mongo', 'redis', 'valkey', 'etcd'];
+export class Keyv extends EventManager {
+    opts;
+    iterator;
+    hooks = new HooksManager();
+    stats = new StatsManager(false);
+    /**
+     * Time to live in milliseconds
+     */
+    _ttl;
+    /**
+     * Namespace
+     */
+    _namespace;
+    /**
+     * Store
+     */
+    _store = new Map();
+    _serialize = defaultSerialize;
+    _deserialize = defaultDeserialize;
+    _compression;
+    _useKeyPrefix = true;
+    _throwOnErrors = false;
+    /**
+     * Keyv Constructor
+     * @param {KeyvStoreAdapter | KeyvOptions} store
+     * @param {Omit<KeyvOptions, 'store'>} [options] if you provide the store you can then provide the Keyv Options
+     */
+    constructor(store, options) {
+        super();
+        options ??= {};
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        store ??= {};
+        this.opts = {
+            namespace: 'keyv',
+            serialize: defaultSerialize,
+            deserialize: defaultDeserialize,
+            emitErrors: true,
+            // @ts-expect-error - Map is not a KeyvStoreAdapter
+            store: new Map(),
+            ...options
+        };
+        if (store && store.get) {
+            this.opts.store = store;
+        }
+        else {
+            this.opts = {
+                ...this.opts,
+                ...store
+            };
+        }
+        this._store = this.opts.store ?? new Map();
+        this._compression = this.opts.compression;
+        // biome-ignore lint/style/noNonNullAssertion: need to fix
+        this._serialize = this.opts.serialize;
+        // biome-ignore lint/style/noNonNullAssertion: need to fix
+        this._deserialize = this.opts.deserialize;
+        /* v8 ignore next -- @preserve */
+        if (this.opts.namespace) {
+            this._namespace = this.opts.namespace;
+        }
+        /* v8 ignore next -- @preserve */
+        if (this._store) {
+            if (!this._isValidStorageAdapter(this._store)) {
+                throw new Error('Invalid storage adapter');
+            }
+            if (typeof this._store.on === 'function') {
+                this._store.on('error', (error) => this.emit('error', error));
+            }
+            this._store.namespace = this._namespace;
+            // Attach iterators
+            if (typeof this._store[Symbol.iterator] === 'function' && this._store instanceof Map) {
+                this.iterator = this.generateIterator(this._store);
+            }
+            else if ('iterator' in this._store && this._store.opts && this._checkIterableAdapter()) {
+                this.iterator = this.generateIterator(
+                // biome-ignore lint/style/noNonNullAssertion: need to fix
+                this._store.iterator.bind(this._store));
+            }
+        }
+        if (this.opts.stats) {
+            this.stats.enabled = this.opts.stats;
+        }
+        if (this.opts.ttl) {
+            this._ttl = this.opts.ttl;
+        }
+        if (this.opts.useKeyPrefix !== undefined) {
+            this._useKeyPrefix = this.opts.useKeyPrefix;
+        }
+        if (this.opts.throwOnErrors !== undefined) {
+            this._throwOnErrors = this.opts.throwOnErrors;
+        }
+    }
+    /**
+     * Get the current store
+     */
+    get store() {
+        return this._store;
+    }
+    /**
+     * Set the current store. This will also set the namespace, event error handler, and generate the iterator. If the store is not valid it will throw an error.
+     * @param {KeyvStoreAdapter | Map<any, any> | any} store the store to set
+     */
+    set store(store) {
+        if (this._isValidStorageAdapter(store)) {
+            this._store = store;
+            this.opts.store = store;
+            if (typeof store.on === 'function') {
+                store.on('error', (error) => this.emit('error', error));
+            }
+            /* v8 ignore next -- @preserve */
+            if (this._namespace) {
+                this._store.namespace = this._namespace;
+            }
+            if (typeof store[Symbol.iterator] === 'function' && store instanceof Map) {
+                this.iterator = this.generateIterator(store);
+                /* v8 ignore next -- @preserve */
+            }
+            else if ('iterator' in store && store.opts && this._checkIterableAdapter()) {
+                this.iterator = this.generateIterator(store.iterator?.bind(store));
+            }
+        }
+        else {
+            throw new Error('Invalid storage adapter');
+        }
+    }
+    /**
+     * Get the current compression function
+     * @returns {CompressionAdapter} The current compression function
+     */
+    get compression() {
+        return this._compression;
+    }
+    /**
+     * Set the current compression function
+     * @param {CompressionAdapter} compress The compression function to set
+     */
+    set compression(compress) {
+        this._compression = compress;
+    }
+    /**
+     * Get the current namespace.
+     * @returns {string | undefined} The current namespace.
+     */
+    get namespace() {
+        return this._namespace;
+    }
+    /**
+     * Set the current namespace.
+     * @param {string | undefined} namespace The namespace to set.
+     */
+    set namespace(namespace) {
+        this._namespace = namespace;
+        this.opts.namespace = namespace;
+        this._store.namespace = namespace;
+        /* v8 ignore next -- @preserve */
+        if (this.opts.store) {
+            this.opts.store.namespace = namespace;
+        }
+    }
+    /**
+     * Get the current TTL.
+     * @returns {number} The current TTL in milliseconds.
+     */
+    get ttl() {
+        return this._ttl;
+    }
+    /**
+     * Set the current TTL.
+     * @param {number} ttl The TTL to set in milliseconds.
+     */
+    set ttl(ttl) {
+        this.opts.ttl = ttl;
+        this._ttl = ttl;
+    }
+    /**
+     * Get the current serialize function.
+     * @returns {Serialize} The current serialize function.
+     */
+    get serialize() {
+        return this._serialize;
+    }
+    /**
+     * Set the current serialize function.
+     * @param {Serialize} serialize The serialize function to set.
+     */
+    set serialize(serialize) {
+        this.opts.serialize = serialize;
+        this._serialize = serialize;
+    }
+    /**
+     * Get the current deserialize function.
+     * @returns {Deserialize} The current deserialize function.
+     */
+    get deserialize() {
+        return this._deserialize;
+    }
+    /**
+     * Set the current deserialize function.
+     * @param {Deserialize} deserialize The deserialize function to set.
+     */
+    set deserialize(deserialize) {
+        this.opts.deserialize = deserialize;
+        this._deserialize = deserialize;
+    }
+    /**
+     * Get the current useKeyPrefix value. This will enable or disable key prefixing.
+     * @returns {boolean} The current useKeyPrefix value.
+     * @default true
+     */
+    get useKeyPrefix() {
+        return this._useKeyPrefix;
+    }
+    /**
+     * Set the current useKeyPrefix value. This will enable or disable key prefixing.
+     * @param {boolean} value The useKeyPrefix value to set.
+     */
+    set useKeyPrefix(value) {
+        this._useKeyPrefix = value;
+        this.opts.useKeyPrefix = value;
+    }
+    /**
+     * Get the current throwErrors value. This will enable or disable throwing errors on methods in addition to emitting them.
+     * @return {boolean} The current throwOnErrors value.
+     */
+    get throwOnErrors() {
+        return this._throwOnErrors;
+    }
+    /**
+     * Set the current throwOnErrors value. This will enable or disable throwing errors on methods in addition to emitting them.
+     * @param {boolean} value The throwOnErrors value to set.
+     */
+    set throwOnErrors(value) {
+        this._throwOnErrors = value;
+        this.opts.throwOnErrors = value;
+    }
+    generateIterator(iterator) {
+        const function_ = async function* () {
+            for await (const [key, raw] of typeof iterator === 'function' ? iterator(this._store.namespace) : iterator) {
+                const data = await this.deserializeData(raw);
+                if (this._useKeyPrefix && this._store.namespace && !key.includes(this._store.namespace)) {
+                    continue;
+                }
+                if (typeof data.expires === 'number' && Date.now() > data.expires) {
+                    await this.delete(key);
+                    continue;
+                }
+                yield [this._getKeyUnprefix(key), data.value];
+            }
+        };
+        return function_.bind(this);
+    }
+    _checkIterableAdapter() {
+        return (iterableAdapters.includes(this._store.opts.dialect) ||
+            iterableAdapters.some((element) => this._store.opts.url.includes(element)));
+    }
+    _getKeyPrefix(key) {
+        if (!this._useKeyPrefix) {
+            return key;
+        }
+        if (!this._namespace) {
+            return key;
+        }
+        // If the key is already prefixed, return it
+        if (key.startsWith(`${this._namespace}:`)) {
+            return key;
+        }
+        return `${this._namespace}:${key}`;
+    }
+    _getKeyPrefixArray(keys) {
+        if (!this._useKeyPrefix) {
+            return keys;
+        }
+        if (!this._namespace) {
+            return keys;
+        }
+        return keys.map((key) => `${this._namespace}:${key}`);
+    }
+    _getKeyUnprefix(key) {
+        if (!this._useKeyPrefix) {
+            return key;
+        }
+        return key.split(':').splice(1).join(':');
+    }
+    _isValidStorageAdapter(store) {
+        return (store instanceof Map ||
+            (typeof store.get === 'function' &&
+                typeof store.set === 'function' &&
+                typeof store.delete === 'function' &&
+                typeof store.clear === 'function'));
+    }
+    async get(key, options) {
+        const { store } = this.opts;
+        const isArray = Array.isArray(key);
+        const keyPrefixed = isArray ? this._getKeyPrefixArray(key) : this._getKeyPrefix(key);
+        const isDataExpired = (data) => typeof data.expires === 'number' && Date.now() > data.expires;
+        if (isArray) {
+            if (options?.raw === true) {
+                return this.getMany(key, { raw: true });
+            }
+            return this.getMany(key, { raw: false });
+        }
+        this.hooks.trigger('preGet', { key: keyPrefixed });
+        let rawData;
+        try {
+            rawData = await store.get(keyPrefixed);
+        }
+        catch (error) {
+            if (this.throwOnErrors) {
+                throw error;
+            }
+        }
+        const deserializedData = typeof rawData === 'string' || this.opts.compression
+            ? await this.deserializeData(rawData)
+            : rawData;
+        if (deserializedData === undefined || deserializedData === null) {
+            this.hooks.trigger('postGet', {
+                key: keyPrefixed,
+                value: undefined
+            });
+            this.stats.miss();
+            return undefined;
+        }
+        if (isDataExpired(deserializedData)) {
+            await this.delete(key);
+            this.hooks.trigger('postGet', {
+                key: keyPrefixed,
+                value: undefined
+            });
+            this.stats.miss();
+            return undefined;
+        }
+        this.hooks.trigger('postGet', {
+            key: keyPrefixed,
+            value: deserializedData
+        });
+        this.stats.hit();
+        return options?.raw ? deserializedData : deserializedData.value;
+    }
+    async getMany(keys, options) {
+        const { store } = this.opts;
+        const keyPrefixed = this._getKeyPrefixArray(keys);
+        const isDataExpired = (data) => typeof data.expires === 'number' && Date.now() > data.expires;
+        this.hooks.trigger('preGetMany', { keys: keyPrefixed });
+        if (store.getMany === undefined) {
+            const promises = keyPrefixed.map(async (key) => {
+                const rawData = await store.get(key);
+                const deserializedRow = typeof rawData === 'string' || this.opts.compression
+                    ? await this.deserializeData(rawData)
+                    : rawData;
+                if (deserializedRow === undefined || deserializedRow === null) {
+                    return undefined;
+                }
+                if (isDataExpired(deserializedRow)) {
+                    await this.delete(key);
+                    return undefined;
+                }
+                return options?.raw
+                    ? deserializedRow
+                    : deserializedRow.value;
+            });
+            const deserializedRows = await Promise.allSettled(promises);
+            const result = deserializedRows.map((row) => row.value);
+            this.hooks.trigger('postGetMany', result);
+            if (result.length > 0) {
+                this.stats.hit();
+            }
+            return result;
+        }
+        const rawData = await store.getMany(keyPrefixed);
+        const result = [];
+        const expiredKeys = [];
+        for (const index in rawData) {
+            let row = rawData[index];
+            if (typeof row === 'string') {
+                row = await this.deserializeData(row);
+            }
+            if (row === undefined || row === null) {
+                result.push(undefined);
+                continue;
+            }
+            if (isDataExpired(row)) {
+                expiredKeys.push(keys[index]);
+                result.push(undefined);
+                continue;
+            }
+            const value = options?.raw
+                ? row
+                : row.value;
+            result.push(value);
+        }
+        if (expiredKeys.length > 0) {
+            await this.deleteMany(expiredKeys);
+        }
+        this.hooks.trigger('postGetMany', result);
+        /* v8 ignore next -- @preserve */
+        if (result.length > 0) {
+            this.stats.hit();
+        }
+        return result;
+    }
+    /**
+     * Get the raw value of a key. This is the replacement for setting raw to true in the get() method.
+     * @param {string} key the key to get
+     * @returns {Promise<StoredDataRaw<Value> | undefined>} will return a StoredDataRaw<Value> or undefined if the key does not exist or is expired.
+     */
+    async getRaw(key) {
+        const { store } = this.opts;
+        const keyPrefixed = this._getKeyPrefix(key);
+        this.hooks.trigger('preGetRaw', { key: keyPrefixed });
+        const rawData = await store.get(keyPrefixed);
+        if (rawData === undefined || rawData === null) {
+            this.hooks.trigger('postGetRaw', {
+                key: keyPrefixed,
+                value: undefined
+            });
+            this.stats.miss();
+            return undefined;
+        }
+        // Check if the data is expired
+        /* v8 ignore next -- @preserve */
+        const deserializedData = typeof rawData === 'string' || this.opts.compression
+            ? await this.deserializeData(rawData)
+            : rawData;
+        if (deserializedData !== undefined &&
+            deserializedData.expires !== undefined &&
+            deserializedData.expires !== null &&
+            deserializedData.expires < Date.now()) {
+            this.hooks.trigger('postGetRaw', {
+                key: keyPrefixed,
+                value: undefined
+            });
+            this.stats.miss();
+            await this.delete(key);
+            return undefined;
+        }
+        // Add a hit
+        this.stats.hit();
+        this.hooks.trigger('postGetRaw', {
+            key: keyPrefixed,
+            value: deserializedData
+        });
+        return deserializedData;
+    }
+    /**
+     * Get the raw values of many keys. This is the replacement for setting raw to true in the getMany() method.
+     * @param {string[]} keys the keys to get
+     * @returns {Promise<Array<StoredDataRaw<Value>>>} will return an array of StoredDataRaw<Value> or undefined if the key does not exist or is expired.
+     */
+    async getManyRaw(keys) {
+        const { store } = this.opts;
+        const keyPrefixed = this._getKeyPrefixArray(keys);
+        if (keys.length === 0) {
+            const result = Array.from({ length: keys.length }).fill(undefined);
+            // Add in misses
+            this.stats.misses += keys.length;
+            // Trigger the post get many raw hook
+            this.hooks.trigger('postGetManyRaw', {
+                keys: keyPrefixed,
+                values: result
+            });
+            return result;
+        }
+        let result = [];
+        // Check to see if the store has a getMany method
+        if (store.getMany === undefined) {
+            // If not then we will get each key individually
+            const promises = keyPrefixed.map(async (key) => {
+                const rawData = await store.get(key);
+                if (rawData !== undefined && rawData !== null) {
+                    return this.deserializeData(rawData);
+                }
+                return undefined;
+            });
+            const deserializedRows = await Promise.allSettled(promises);
+            result = deserializedRows.map((row) => row.value);
+        }
+        else {
+            const rawData = await store.getMany(keyPrefixed);
+            for (const row of rawData) {
+                /* v8 ignore next -- @preserve */
+                if (row !== undefined && row !== null) {
+                    result.push(await this.deserializeData(row));
+                }
+                else {
+                    /* v8 ignore next -- @preserve */
+                    result.push(undefined);
+                }
+            }
+        }
+        // Filter out any expired keys and delete them
+        const expiredKeys = [];
+        const isDataExpired = (data) => typeof data.expires === 'number' && Date.now() > data.expires;
+        for (const [index, row] of result.entries()) {
+            if (row !== undefined && isDataExpired(row)) {
+                expiredKeys.push(keyPrefixed[index]);
+                result[index] = undefined;
+            }
+        }
+        if (expiredKeys.length > 0) {
+            await this.deleteMany(expiredKeys);
+        }
+        // Add in hits and misses
+        this.stats.hitsOrMisses(result);
+        // Trigger the post get many raw hook
+        this.hooks.trigger('postGetManyRaw', {
+            keys: keyPrefixed,
+            values: result
+        });
+        return result;
+    }
+    /**
+     * Set an item to the store
+     * @param {string | Array<KeyvEntry>} key the key to use. If you pass in an array of KeyvEntry it will set many items
+     * @param {Value} value the value of the key
+     * @param {number} [ttl] time to live in milliseconds
+     * @returns {boolean} if it sets then it will return a true. On failure will return false.
+     */
+    async set(key, value, ttl) {
+        const data = { key, value, ttl };
+        this.hooks.trigger('preSet', data);
+        const keyPrefixed = this._getKeyPrefix(data.key);
+        data.ttl ??= this._ttl;
+        if (data.ttl === 0) {
+            data.ttl = undefined;
+        }
+        const { store } = this.opts;
+        const expires = typeof data.ttl === 'number' ? Date.now() + data.ttl : undefined;
+        if (typeof data.value === 'symbol') {
+            this.emit('error', 'symbol cannot be serialized');
+            throw new Error('symbol cannot be serialized');
+        }
+        const formattedValue = { value: data.value, expires };
+        const serializedValue = await this.serializeData(formattedValue);
+        let result = true;
+        try {
+            const value = await store.set(keyPrefixed, serializedValue, data.ttl);
+            if (typeof value === 'boolean') {
+                result = value;
+            }
+        }
+        catch (error) {
+            result = false;
+            this.emit('error', error);
+            if (this._throwOnErrors) {
+                throw error;
+            }
+        }
+        this.hooks.trigger('postSet', {
+            key: keyPrefixed,
+            value: serializedValue,
+            ttl
+        });
+        this.stats.set();
+        return result;
+    }
+    /**
+     * Set many items to the store
+     * @param {Array<KeyvEntry>} entries the entries to set
+     * @returns {boolean[]} will return an array of booleans if it sets then it will return a true. On failure will return false.
+     */
+    async setMany(entries) {
+        let results = [];
+        try {
+            // If the store doesn't have a setMany method then fall back to setting each entry individually
+            if (this._store.setMany === undefined) {
+                const promises = [];
+                for (const entry of entries) {
+                    promises.push(this.set(entry.key, entry.value, entry.ttl));
+                }
+                const promiseResults = await Promise.all(promises);
+                results = promiseResults;
+            }
+            else {
+                const serializedEntries = await Promise.all(entries.map(async ({ key, value, ttl }) => {
+                    ttl ??= this._ttl;
+                    /* v8 ignore next -- @preserve */
+                    if (ttl === 0) {
+                        ttl = undefined;
+                    }
+                    /* v8 ignore next -- @preserve */
+                    const expires = typeof ttl === 'number' ? Date.now() + ttl : undefined;
+                    /* v8 ignore next -- @preserve */
+                    if (typeof value === 'symbol') {
+                        this.emit('error', 'symbol cannot be serialized');
+                        throw new Error('symbol cannot be serialized');
+                    }
+                    const formattedValue = { value, expires };
+                    const serializedValue = await this.serializeData(formattedValue);
+                    const keyPrefixed = this._getKeyPrefix(key);
+                    return { key: keyPrefixed, value: serializedValue, ttl };
+                }));
+                results = await this._store.setMany(serializedEntries);
+            }
+        }
+        catch (error) {
+            this.emit('error', error);
+            if (this._throwOnErrors) {
+                throw error;
+            }
+            results = entries.map(() => false);
+        }
+        return results;
+    }
+    /**
+     * Delete an Entry
+     * @param {string | string[]} key the key to be deleted. if an array it will delete many items
+     * @returns {boolean} will return true if item or items are deleted. false if there is an error
+     */
+    async delete(key) {
+        const { store } = this.opts;
+        if (Array.isArray(key)) {
+            return this.deleteMany(key);
+        }
+        const keyPrefixed = this._getKeyPrefix(key);
+        this.hooks.trigger('preDelete', { key: keyPrefixed });
+        let result = true;
+        try {
+            const value = await store.delete(keyPrefixed);
+            /* v8 ignore next -- @preserve */
+            if (typeof value === 'boolean') {
+                result = value;
+            }
+        }
+        catch (error) {
+            result = false;
+            this.emit('error', error);
+            if (this._throwOnErrors) {
+                throw error;
+            }
+        }
+        this.hooks.trigger('postDelete', {
+            key: keyPrefixed,
+            value: result
+        });
+        this.stats.delete();
+        return result;
+    }
+    /**
+     * Delete many items from the store
+     * @param {string[]} keys the keys to be deleted
+     * @returns {boolean} will return true if item or items are deleted. false if there is an error
+     */
+    async deleteMany(keys) {
+        try {
+            const { store } = this.opts;
+            const keyPrefixed = this._getKeyPrefixArray(keys);
+            this.hooks.trigger('preDelete', { key: keyPrefixed });
+            if (store.deleteMany !== undefined) {
+                return await store.deleteMany(keyPrefixed);
+            }
+            const promises = keyPrefixed.map(async (key) => store.delete(key));
+            const results = await Promise.all(promises);
+            const returnResult = results.every(Boolean);
+            this.hooks.trigger('postDelete', {
+                key: keyPrefixed,
+                value: returnResult
+            });
+            return returnResult;
+        }
+        catch (error) {
+            this.emit('error', error);
+            if (this._throwOnErrors) {
+                throw error;
+            }
+            return false;
+        }
+    }
+    /**
+     * Clear the store
+     * @returns {void}
+     */
+    async clear() {
+        this.emit('clear');
+        const { store } = this.opts;
+        try {
+            await store.clear();
+        }
+        catch (error) {
+            this.emit('error', error);
+            if (this._throwOnErrors) {
+                throw error;
+            }
+        }
+    }
+    async has(key) {
+        if (Array.isArray(key)) {
+            return this.hasMany(key);
+        }
+        const keyPrefixed = this._getKeyPrefix(key);
+        const { store } = this.opts;
+        if (store.has !== undefined && !(store instanceof Map)) {
+            return store.has(keyPrefixed);
+        }
+        let rawData;
+        try {
+            rawData = await store.get(keyPrefixed);
+        }
+        catch (error) {
+            this.emit('error', error);
+            if (this._throwOnErrors) {
+                throw error;
+            }
+            return false;
+        }
+        if (rawData) {
+            const data = (await this.deserializeData(rawData));
+            /* v8 ignore next -- @preserve */
+            if (data) {
+                if (data.expires === undefined || data.expires === null) {
+                    return true;
+                }
+                return data.expires > Date.now();
+            }
+        }
+        return false;
+    }
+    /**
+     * Check if many keys exist
+     * @param {string[]} keys the keys to check
+     * @returns {boolean[]} will return an array of booleans if the keys exist
+     */
+    async hasMany(keys) {
+        const keyPrefixed = this._getKeyPrefixArray(keys);
+        const { store } = this.opts;
+        if (store.hasMany !== undefined) {
+            return store.hasMany(keyPrefixed);
+        }
+        const results = [];
+        for (const key of keys) {
+            // eslint-disable-next-line no-await-in-loop
+            results.push(await this.has(key));
+        }
+        return results;
+    }
+    /**
+     * Will disconnect the store. This is only available if the store has a disconnect method
+     * @returns {Promise<void>}
+     */
+    async disconnect() {
+        const { store } = this.opts;
+        this.emit('disconnect');
+        if (typeof store.disconnect === 'function') {
+            return store.disconnect();
+        }
+    }
+    emit(event, ...arguments_) {
+        if (event === 'error' && !this.opts.emitErrors) {
+            return;
+        }
+        super.emit(event, ...arguments_);
+    }
+    async serializeData(data) {
+        if (!this._serialize) {
+            return data;
+        }
+        if (this._compression?.compress) {
+            return this._serialize({
+                value: await this._compression.compress(data.value),
+                expires: data.expires
+            });
+        }
+        return this._serialize(data);
+    }
+    async deserializeData(data) {
+        if (!this._deserialize) {
+            return data;
+        }
+        if (this._compression?.decompress && typeof data === 'string') {
+            const result = await this._deserialize(data);
+            return {
+                value: await this._compression.decompress(result?.value),
+                expires: result?.expires
+            };
+        }
+        if (typeof data === 'string') {
+            return this._deserialize(data);
+        }
+        return undefined;
+    }
+}
+export default Keyv;
+//# sourceMappingURL=index.js.map