@e-mc/core 0.13.4 → 0.13.6

package/README.md

@@ -9,7 +9,7 @@
 
 ## Interface
 
-* [View Source](https://www.unpkg.com/@e-mc/types@0.13.4/lib/index.d.ts)
+* [View Source](https://www.unpkg.com/@e-mc/types@0.13.6/lib/index.d.ts)
 
 ```typescript
 import type { DataSource, LogStatus, WorkerAction } from "./squared";
@@ -74,7 +74,7 @@ interface HostConstructor extends ModuleConstructor {
     getThreadCount(full: true): ThreadCountStat;
     getThreadCount(username: string, iv?: BinaryLike): ThreadCountStat;
     getThreadCount(username?: string | boolean, iv?: BinaryLike): number;
-    getPermissionFromSettings(): IPermission;
+    getPermissionFromSettings(freeze?: boolean): IPermission;
     readonly prototype: IHost;
     new(config?: HostInitConfig): IHost;
 }
@@ -132,10 +132,13 @@ interface ClientDbConstructor extends ClientConstructor<IHost, ClientModule> {
     convertTime(value: number | string): number;
     findResult(source: string, credential: unknown, queryString: string, timeout: number, sessionKey?: string | boolean, renewCache?: boolean): QueryResult | undefined;
     storeResult(source: string, credential: unknown, queryString: string, result: QueryResult, options: StoreResultOptions): QueryResult;
+    /** @deprecated */
     storeResult(source: string, credential: unknown, queryString: string, result: QueryResult, sessionKey: string, sessionExpires: number): QueryResult;
     storeResult(source: string, credential: unknown, queryString: string, result: QueryResult, cache: DbCacheValue): QueryResult;
-    storeResult(source: string, credential: unknown, queryString: string, result: QueryResult, cache: DbCacheValue | undefined, options: StoreResultOptions): QueryResult;
-    purgeResult(prefix?: string): Promise<number>;
+    storeResult(source: string, credential: unknown, queryString: string, result: QueryResult, cache: DbCacheValue | undefined, options: Omit<StoreResultOptions, "cache">): QueryResult;
+    findSession(source: string, user: string, key: string): unknown;
+    storeSession(source: string, user: string, key: string, result: unknown, expires?: number): void;
+    purgeResult(prefix?: string, lru?: boolean | number): Promise<number>;
     extractUUID(credential: unknown): string;
     setPoolConfig(value: unknown): void;
     getPoolConfig(source: string): unknown;
@@ -319,13 +322,13 @@ NOTE: **@e-mc/core** is mostly a collection of abstract base classes which canno
 
 ## References
 
-- https://www.unpkg.com/@e-mc/types@0.13.4/lib/squared.d.ts
-- https://www.unpkg.com/@e-mc/types@0.13.4/lib/core.d.ts
-- https://www.unpkg.com/@e-mc/types@0.13.4/lib/db.d.ts
-- https://www.unpkg.com/@e-mc/types@0.13.4/lib/dom.d.ts
-- https://www.unpkg.com/@e-mc/types@0.13.4/lib/logger.d.ts
-- https://www.unpkg.com/@e-mc/types@0.13.4/lib/node.d.ts
-- https://www.unpkg.com/@e-mc/types@0.13.4/lib/settings.d.ts
+- https://www.unpkg.com/@e-mc/types@0.13.6/lib/squared.d.ts
+- https://www.unpkg.com/@e-mc/types@0.13.6/lib/core.d.ts
+- https://www.unpkg.com/@e-mc/types@0.13.6/lib/db.d.ts
+- https://www.unpkg.com/@e-mc/types@0.13.6/lib/dom.d.ts
+- https://www.unpkg.com/@e-mc/types@0.13.6/lib/logger.d.ts
+- https://www.unpkg.com/@e-mc/types@0.13.6/lib/node.d.ts
+- https://www.unpkg.com/@e-mc/types@0.13.6/lib/settings.d.ts
 
 * https://www.npmjs.com/package/@types/node
 

package/index.js

@@ -3,7 +3,6 @@ var _a;
 exports.Module = exports.Permission = exports.AbortComponent = exports.WorkerChannel = exports.WorkerGroup = exports.ClientDb = exports.Client = exports.Host = void 0;
 const path = require("node:path");
 const fs = require("node:fs");
-const os = require("node:os");
 const pm = require("picomatch");
 const ipaddr = require("ipaddr.js");
 const EventEmitter = require("node:events");
@@ -15,7 +14,7 @@ exports.Module = module_1;
 const kHost = Symbol.for('host:constructor');
 const kClient = Symbol.for('client:constructor');
 const kClientDb = Symbol.for('clientdb:constructor');
-const CACHE_USER = {};
+const CACHE_USER = Object.create(null);
 const CACHE_SOURCE = Object.create(null);
 const CACHE_SESSION = Object.create(null);
 const ABORT_LISTENER = new WeakMap();
@@ -43,7 +42,7 @@ const HOST = {
     LOG_PROGRESS_PAUSED: new Set()
 };
 const WORKER_GROUP = {
-    MAX: (0, types_1.supported)(19, 4) || (0, types_1.supported)(18, 14, true) ? os.availableParallelism() : os.cpus().length,
+    MAX: module_1.availableParallelism(),
     TIMEOUT: Infinity,
     LOCKED: true
 };
@@ -159,65 +158,13 @@ function resumeHostQueue(item, aborted) {
 function encryptText(data, iv) {
     return HOST.CIPHER && (0, types_1.isString)(data) && (0, types_1.encryptUTF8)(HOST.CIPHER.algorithm, HOST.CIPHER.key, iv, data) || '';
 }
-function clearSourceResult(data) {
-    const result = data[1];
-    data[1] = null;
-    if (typeof result === 'string') {
-        fs.unlink(result, () => { });
-    }
-}
-function addSourceResult(source, data) {
-    const { items, config } = CACHE_SOURCE[source] ||= { items: [] };
-    if (config && items.length >= config.limit) {
-        const { percent, min } = config;
-        if (percent === 1) {
-            for (const item of items) {
-                clearSourceResult(item);
-            }
-            items.length = 0;
-        }
-        else {
-            items.sort((a, b) => a[2] - b[2]);
-            for (let i = 0, length = Math.floor(items.length * percent); i < length; ++i) {
-                const item = items[i];
-                if (min === 0 || item[3] < min) {
-                    clearSourceResult(item);
-                    items.splice(i--, 1);
-                    --length;
-                }
-            }
-        }
-    }
-    items.push(data);
-}
-function deleteSourceResult(source, data) {
-    const stored = CACHE_SOURCE[source];
-    if (stored) {
-        const items = stored.items;
-        const index = items.findIndex(item => item === data);
-        if (index !== -1) {
-            items.splice(index, 1);
-        }
-    }
-}
-function incrementSourceCount(source, data, cacheData, queryString) {
-    const count = ++data[3];
-    const stored = CACHE_SOURCE[source];
-    if (stored?.config && count >= stored.config.max) {
-        clearSourceResult(data);
-        deleteSourceResult(source, data);
-        if (cacheData && queryString) {
-            delete cacheData[queryString];
-        }
-    }
-}
 function getSettingsValue(options, name, component) {
     const result = options[name];
     return component ? (0, types_1.isObject)(result) ? result[component] : undefined : result;
 }
 function isInvalidRange(result, range) {
     const [lower, upper = 0] = range;
-    return result.length <= lower || upper > 0 && result.length > upper;
+    return Array.isArray(result) && (result.length <= lower || upper > 0 && result.length > upper);
 }
 function asPosix(value) {
     if (module_1.PLATFORM_WIN32) {
@@ -251,6 +198,192 @@ function parseIp(value, kind) {
 const readable = (value) => (0, types_1.isString)(value) || (0, types_1.isArray)(value);
 const expireTime = (value) => Date.now() + value * 1000;
 const convertSeconds = (value) => typeof value === 'string' && Math.ceil((0, types_1.parseTime)(value) / 1000) || 0;
+class DbLRU {
+    static get(source) {
+        return CACHE_SOURCE[source] ||= new DbLRU();
+    }
+    static purge(source, value) {
+        const target = this.get(source);
+        const items = target.items;
+        for (let i = 0, length = items.length; i < length; ++i) {
+            const item = items[i];
+            if (item.value === value) {
+                item.delete(false);
+                items.splice(i, 1);
+                return true;
+            }
+        }
+        return false;
+    }
+    items = [];
+    config = null;
+    refresh(percent) {
+        const { items, config } = this;
+        let result = 0;
+        if (config && items.length >= config.limit || percent) {
+            percent = Math.min(1, percent ?? config.percent);
+            if (percent === 1) {
+                result = items.length;
+                for (let i = 0; i < result; ++i) {
+                    items[i].delete(false);
+                }
+                items.length = 0;
+            }
+            else {
+                const min = config?.min || 0;
+                const data = items.slice(0).sort((a, b) => a.lastAccessed - b.lastAccessed);
+                for (let i = 0, length = Math.floor(data.length * Math.min(percent, 1)); i < length; ++i) {
+                    const item = data[i];
+                    if (min === 0 || item.accessCount < min) {
+                        item.delete(true);
+                        ++result;
+                    }
+                }
+            }
+        }
+        return result;
+    }
+}
+class DbCache {
+    source;
+    user;
+    query;
+    value;
+    expires;
+    accessCount = 0;
+    lastAccessed = Date.now();
+    disposed = false;
+    userData;
+    queryData;
+    sourceList;
+    constructor(source, user, query, value, expires) {
+        this.source = source;
+        this.user = user;
+        this.query = query;
+        this.value = value;
+        this.expires = expires;
+        this.userData = CACHE_USER[source] ||= Object.create(null);
+        this.queryData = this.userData[user] ||= Object.create(null);
+        this.queryData[query] = this;
+        this.sourceList = DbLRU.get(source);
+        this.sourceList.refresh();
+        this.sourceList.items.push(this);
+    }
+    get(seconds) {
+        const current = Date.now();
+        if (seconds > 0) {
+            this.expires = expireTime(seconds);
+        }
+        else if (current >= this.expires) {
+            this.delete(true);
+            return;
+        }
+        let result = this.value;
+        if (typeof result === 'string') {
+            try {
+                result = JSON.parse(fs.readFileSync(result, 'utf8'));
+            }
+            catch {
+                result = null;
+            }
+        }
+        if (Array.isArray(result)) {
+            this.update(current);
+            return result;
+        }
+        this.delete(true);
+    }
+    update(current) {
+        const count = ++this.accessCount;
+        const config = this.sourceList.config;
+        if (config && count >= config.max) {
+            this.delete(true);
+        }
+        else {
+            this.lastAccessed = current;
+        }
+    }
+    delete(lru) {
+        if (!this.disposed) {
+            const value = this.value;
+            this.value = null;
+            this.queryData[this.query] = null;
+            this.disposed = true;
+            if (lru) {
+                const items = this.sourceList.items;
+                const index = items.findIndex(item => item === this);
+                if (index !== -1) {
+                    items.splice(index, 1);
+                }
+            }
+            void this.cleanup(value);
+        }
+    }
+    async cleanup(value) {
+        const data = this.queryData;
+        let found = false;
+        for (const query in data) {
+            if (data[query]) {
+                found = true;
+                break;
+            }
+        }
+        if (!found) {
+            delete this.userData[this.user];
+        }
+        if (typeof value === 'string') {
+            try {
+                fs.unlinkSync(value);
+            }
+            catch {
+            }
+        }
+    }
+    expired(current) {
+        if (current >= this.expires) {
+            this.delete(true);
+            return true;
+        }
+        return false;
+    }
+}
+class DbSession {
+    source;
+    sourceData = Object.create(null);
+    constructor(source) {
+        this.source = source;
+        const timer = setInterval(() => {
+            this.clear();
+            if (this.users.length === 0) {
+                CACHE_SESSION[source] = undefined;
+                clearInterval(timer);
+            }
+        }, 60000);
+    }
+    set(user, key, result, seconds) {
+        let data = this.sourceData[user];
+        if (!data) {
+            data = [Object.create(null), Date.now() + Math.trunc(seconds * 1000)];
+            this.sourceData[user] = data;
+        }
+        data[0][key] = result;
+    }
+    get(user, key) {
+        return this.sourceData[user]?.[0][key];
+    }
+    clear() {
+        const current = Date.now();
+        for (const user of this.users) {
+            const expires = this.sourceData[user][1];
+            if (expires >= current) {
+                delete this.sourceData[user];
+            }
+        }
+    }
+    get users() {
+        return Object.keys(this.sourceData);
+    }
+}
 class Host extends module_1 {
     static [kHost] = true;
     static async purgeMemory(percent = 1, limit = 0, parent) {
@@ -281,6 +414,7 @@ class Host extends module_1 {
                 if (permission.unc_write) {
                     PERMISSION.setUNCWrite(unc_write);
                 }
+                Object.freeze(PERMISSION);
             }
             if (perm.settings) {
                 const { picomatch: pico, minimatch: mini } = perm.settings;
@@ -486,8 +620,8 @@ class Host extends module_1 {
     static getLogDelayed() {
         return HOST.LOG_DELAYED;
     }
-    static getPermissionFromSettings() {
-        return PERMISSION;
+    static getPermissionFromSettings(freeze = true) {
+        return freeze ? PERMISSION : Permission.clone(PERMISSION);
     }
     restartable = true;
     modules = new Set();
@@ -896,7 +1030,6 @@ class ClientDb extends Client {
                         const item = client[source];
                         if ((0, types_1.isPlainObject)(item) && 'enabled' in item) {
                             const key = name + '_' + source;
-                            const stored = CACHE_SOURCE[key];
                             const { enabled, limit = 0, min = 0, max = 0 } = item;
                             if (enabled && +limit > 0) {
                                 let percent = item.percent || 0;
@@ -907,11 +1040,16 @@ class ClientDb extends Client {
                                     percent /= 100;
                                 }
                                 if (percent > 0) {
-                                    (stored || (CACHE_SOURCE[key] = { items: [] })).config = { limit: +limit > 0 ? +limit : 0, percent: Math.min(percent, 1), min: min > 0 ? min : 0, max: max > 0 ? max : Infinity };
+                                    DbLRU.get(key).config = {
+                                        limit: +limit,
+                                        percent: Math.min(percent, 1),
+                                        min: min > 0 ? min : 0,
+                                        max: max > 0 ? max : Infinity
+                                    };
                                 }
                             }
-                            else if (stored) {
-                                delete stored.config;
+                            else if (CACHE_SOURCE[key]) {
+                                CACHE_SOURCE[key].config = null;
                             }
                         }
                     }
@@ -958,96 +1096,63 @@ class ClientDb extends Client {
     }
     static findResult(source, credential, queryString, timeout, sessionKey, renewCache) {
         const userKey = credential ? this.extractUUID(credential) || (0, types_1.hashKey)(this.asString(credential)) : undefined;
-        if (!userKey) {
-            return;
-        }
-        queryString = (0, types_1.hashKey)(queryString);
-        if (timeout > 0) {
-            const userCache = CACHE_USER[source]?.[userKey];
-            let stored;
-            if (!(userCache && (stored = userCache[queryString]))) {
-                return;
-            }
-            const [expires, result] = stored;
-            if (result) {
-                const current = Date.now();
-                let valid = false;
-                if (renewCache) {
-                    stored[0] = expireTime(timeout);
-                    valid = true;
-                }
-                else if (current < expires) {
-                    valid = true;
-                }
-                if (valid) {
-                    stored[2] = current;
-                    incrementSourceCount(source, stored, userCache, queryString);
-                    if (Array.isArray(result)) {
-                        return result;
-                    }
-                    try {
-                        return JSON.parse(fs.readFileSync(result, 'utf8'));
-                    }
-                    catch {
-                    }
+        if (userKey) {
+            queryString = (0, types_1.hashKey)(queryString);
+            if (timeout > 0) {
+                const stored = CACHE_USER[source]?.[userKey]?.[queryString];
+                if (stored) {
+                    return stored.get(renewCache ? timeout : 0);
                 }
-                clearSourceResult(stored);
             }
-            deleteSourceResult(source, stored);
-            delete userCache[queryString];
-        }
-        else if (sessionKey) {
-            return CACHE_SESSION[source]?.[userKey + sessionKey]?.[queryString];
+            else if (sessionKey) {
+                return this.findSession(source, userKey + sessionKey, queryString);
+            }
         }
     }
-    static storeResult(source, credential, queryString, result, options, sessionKey, sessionExpires) {
-        if (!credential) {
+    static storeResult(source, credential, queryString, result, cache, sessionKey, sessionExpires) {
+        if (!credential || !Array.isArray(result)) {
             return result;
         }
-        let cache, cacheDir;
+        let cacheDir;
         if ((0, types_1.isObject)(sessionKey)) {
             ({ cacheDir, sessionKey, sessionExpires } = sessionKey);
         }
-        else if ((0, types_1.isObject)(options) && 'cache' in options) {
-            ({ cache, cacheDir, sessionKey, sessionExpires } = options);
+        else if ((0, types_1.isObject)(cache) && 'cache' in cache) {
+            ({ cache, cacheDir, sessionKey, sessionExpires } = cache);
         }
         let timeout = 0, userKey, whenEmpty, partition = false;
-        if (cache) {
-            switch (typeof cache) {
-                case 'number':
-                    timeout = cache;
-                    break;
-                case 'string':
-                    if (typeof sessionKey === 'number') {
-                        sessionExpires = sessionKey;
-                        sessionKey = cache;
-                        break;
-                    }
-                    timeout = convertSeconds(cache);
-                    break;
-                case 'object': {
-                    let seconds, dir;
-                    ({ timeout: seconds, when_empty: whenEmpty, dir } = cache);
-                    if ((0, types_1.isString)(dir) && (!cacheDir || module_1.isDir(dir))) {
-                        cacheDir = dir;
-                        partition = true;
-                    }
-                    if (typeof seconds === 'number') {
-                        timeout = seconds;
-                    }
-                    else {
-                        cache.timeout = seconds ? convertSeconds(seconds) : 0;
-                    }
-                    break;
+        switch (typeof cache) {
+            case 'object': {
+                let seconds, dir;
+                ({ timeout: seconds, when_empty: whenEmpty, dir } = cache);
+                if (dir && (!cacheDir || module_1.isDir(dir))) {
+                    cacheDir = dir;
+                    partition = true;
+                }
+                if (typeof seconds === 'number') {
+                    timeout = seconds;
                 }
+                else {
+                    cache.timeout = seconds ? timeout = convertSeconds(seconds) : 0;
+                }
+                break;
             }
+            case 'number':
+                timeout = cache;
+                break;
+            case 'string':
+                if (typeof sessionKey === 'number') {
+                    sessionExpires = sessionKey;
+                    sessionKey = cache;
+                    break;
+                }
+                timeout = convertSeconds(cache);
+                break;
         }
         if ((result.length > 0 || whenEmpty) && (userKey = this.extractUUID(credential) || (0, types_1.hashKey)(this.asString(credential)))) {
             queryString = (0, types_1.hashKey)(queryString);
             if (timeout > 0) {
-                const item = [expireTime(timeout), result, Date.now(), 0];
-                ((CACHE_USER[source] ||= {})[userKey] ||= {})[queryString] = item;
-                addSourceResult(source, item);
+                const item = new DbCache(source, userKey, queryString, result, expireTime(timeout));
                 if (cacheDir) {
                     if (partition) {
                         if (STORE_RESULT_COUNT === this.STORE_RESULT_PARTITION_SIZE) {
@@ -1061,61 +1166,62 @@ class ClientDb extends Client {
                     const pathname = path.join(cacheDir, queryString);
                     fs.writeFile(pathname, JSON.stringify(result), err => {
                         if (!err) {
-                            item[1] = pathname;
+                            item.value = pathname;
                         }
                     });
                 }
             }
-            else if (typeof sessionKey === 'string' && sessionExpires && sessionExpires > 0) {
-                const dbKey = userKey + sessionKey;
-                ((CACHE_SESSION[source] ||= {})[dbKey] ||= {})[queryString] = result;
-                setTimeout(() => delete CACHE_SESSION[dbKey], sessionExpires * 1000);
+            else if (typeof sessionKey === 'string' && typeof sessionExpires === 'number' && sessionExpires > 0) {
+                this.storeSession(source, userKey + sessionKey, queryString, result, sessionExpires);
             }
         }
         return result;
     }
-    static async purgeResult(prefix) {
-        const current = Date.now();
-        const providers = new Map();
+    static findSession(source, user, key) {
+        return CACHE_SESSION[source]?.get(user, key);
+    }
+    static storeSession(source, user, key, result, expires = 600) {
+        (CACHE_SESSION[source] ||= new DbSession(source)).set(user, key, result, expires);
+    }
+    static async purgeResult(prefix, lru) {
+        const cache = lru ? CACHE_SOURCE : CACHE_USER;
+        const items = [];
         if (prefix) {
             if (!prefix.includes('_')) {
                 prefix += '_';
-                for (const key in CACHE_USER) {
+                for (const key in cache) {
                     if (key.startsWith(prefix)) {
-                        providers.set(key, CACHE_USER[key]);
+                        items.push(cache[key]);
                     }
                 }
             }
-            else {
-                const source = CACHE_USER[prefix];
-                if (source) {
-                    providers.set(prefix, source);
-                }
+            else if (cache[prefix]) {
+                items.push(cache[prefix]);
             }
         }
         else {
-            for (const key in CACHE_USER) {
-                providers.set(key, CACHE_USER[key]);
+            for (const key in cache) {
+                items.push(cache[key]);
             }
         }
         let result = 0;
-        for (const [source, data] of providers) {
-            for (const user in data) {
-                const queries = data[user];
-                for (const query in queries) {
-                    const item = queries[query];
-                    if (current >= item[0]) {
-                        ++result;
-                        delete queries[query];
-                        deleteSourceResult(source, item);
-                        if (typeof item[1] === 'string') {
-                            fs.unlink(item[1], () => { });
+        if (lru) {
+            for (const source of items) {
+                result += source.refresh(typeof lru === 'number' ? lru : undefined);
+            }
+        }
+        else {
+            const current = Date.now();
+            for (const source of items) {
+                for (const session in source) {
+                    const data = source[session];
+                    for (const query in data) {
+                        const item = data[query];
+                        if (item.expired(current)) {
+                            ++result;
                         }
                     }
                 }
-                if (Object.keys(queries).length === 0) {
-                    delete data[user];
-                }
             }
         }
         return result;
@@ -1201,14 +1307,14 @@ class ClientDb extends Client {
                 break;
             case 'object':
                 if (options !== null) {
-                    ({ value, sessionKey, renewCache, exclusiveOf } = options);
+                    ({ value, sessionKey, exclusiveOf, renewCache } = options);
                     if (Array.isArray(exclusiveOf)) {
                         const ignoreCache = exclusiveOf[2];
                         if (ignoreCache === 1) {
                             return;
                         }
                         renewCache ||= ignoreCache === 0;
-                        queryString += '_' + exclusiveOf.toString();
+                        queryString += '_' + exclusiveOf.slice(0, 2).toString();
                     }
                 }
                 break;
@@ -1220,8 +1326,14 @@ class ClientDb extends Client {
                 value = cache;
             }
         }
-        const result = ClientDb.findResult(this.moduleName + '_' + source, uuidKey || credential, queryString, value === 0 ? 0 : ClientDb.getTimeout(value || this.settingsOf(source, 'cache')), sessionKey, renewCache);
-        if (!exclusiveOf || !isInvalidRange(result, exclusiveOf)) {
+        const result = ClientDb.findResult(this.getSourceName(source), uuidKey || credential, queryString, value === 0 ? 0 : ClientDb.getTimeout(value || this.settingsOf(source, 'cache')), sessionKey, renewCache);
+        if (result) {
+            if (exclusiveOf && isInvalidRange(result, exclusiveOf)) {
+                if (exclusiveOf[2] === 2) {
+                    DbLRU.purge(this.getSourceName(source), result);
+                }
+                return;
+            }
             return result;
         }
     }
@@ -1233,30 +1345,37 @@ class ClientDb extends Client {
             return result;
         }
         const uuidKey = ClientDb.extractUUID(credential);
-        let options;
-        if (this.hasPermission('memory')) {
-            let value, exclusiveOf;
-            if ((0, types_1.isObject)(sessionKey)) {
-                ({ value, sessionKey, exclusiveOf } = sessionKey);
+        let value, exclusiveOf;
+        if ((0, types_1.isObject)(sessionKey)) {
+            ({ value, sessionKey, exclusiveOf } = sessionKey);
+        }
+        if (Array.isArray(exclusiveOf)) {
+            if (isInvalidRange(result, exclusiveOf)) {
+                return result;
             }
-            if (Array.isArray(exclusiveOf)) {
-                if (isInvalidRange(result, exclusiveOf)) {
-                    return result;
-                }
-                queryString += '_' + exclusiveOf.toString();
+            queryString += '_' + exclusiveOf.slice(0, 2).toString();
+        }
+        if (uuidKey) {
+            const cache = this.settingsKey(uuidKey, 'cache');
+            if (cache !== undefined) {
+                value = cache;
             }
-            if (uuidKey) {
-                const cache = this.settingsKey(uuidKey, 'cache');
-                if (cache !== undefined) {
-                    value = cache;
-                }
+        }
+        const cacheDir = this.cacheDir;
+        value ??= this.settingsOf(source, 'cache');
+        let options;
+        if (this.hasPermission('memory')) {
+            if (cacheDir || sessionKey) {
+                options = { cacheDir, sessionKey, sessionExpires: this.cacheExpires / 1000 };
             }
-            options = { cache: value === 0 ? 0 : value || this.settingsOf(source, 'cache'), cacheDir: this.cacheDir, sessionKey, sessionExpires: this.cacheExpires / 1000 };
         }
-        else {
-            options = { cacheDir: this.cacheDir };
+        else if (cacheDir) {
+            options = { cacheDir };
+        }
+        else if (!(0, types_1.isObject)(value) || !(0, types_1.isString)(value.dir)) {
+            return result;
         }
-        return ClientDb.storeResult(this.moduleName + '_' + source, uuidKey || credential, queryString, result, options);
+        return value || options ? ClientDb.storeResult(this.getSourceName(source), uuidKey || credential, queryString, result, value, options) : result;
     }
     getCacheResult(source, credential, queryString, cacheValue, ignoreCache) {
         if (ignoreCache !== 1) {
@@ -1301,6 +1420,9 @@ class ClientDb extends Client {
             return getSettingsValue(data, name, component);
         }
     }
+    getSourceName(value) {
+        return this.moduleName + '_' + value;
+    }
     get pending() {
         return this.database.filter(item => {
             const state = item.transactionState || 0;
@@ -2017,3 +2139,4 @@ class Permission {
 exports.Permission = Permission;
 _a = Permission;
 PERMISSION = Host.createPermission(true, true);
+Object.freeze(PERMISSION);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@e-mc/core",
-  "version": "0.13.4",
+  "version": "0.13.6",
   "description": "Core modules for E-mc.",
   "main": "index.js",
   "types": "index.d.ts",
@@ -19,9 +19,9 @@
   "license": "BSD-3-Clause",
   "homepage": "https://github.com/anpham6/e-mc#readme",
   "dependencies": {
-    "@e-mc/module": "0.13.4",
-    "@e-mc/types": "0.13.4",
-    "ipaddr.js": "^2.2.0",
+    "@e-mc/module": "0.13.6",
+    "@e-mc/types": "0.13.6",
+    "ipaddr.js": "^2.3.0",
     "picomatch": "^4.0.3"
   }
 }