namirasoft-node-redis 1.4.39 → 1.4.41

package/dist/RedisInstance.d.ts

@@ -1,6 +1,10 @@
 import * as Redis from "ioredis";
 import { IDatabase } from "namirasoft-node";
 export declare abstract class RedisInstance implements IDatabase {
+    private host;
+    private port;
+    private password;
+    private db;
     client: Redis.Redis;
     constructor(host: string, port: number, password: string, db?: number);
     getType(): string;

package/dist/RedisInstance.js

@@ -47,10 +47,10 @@ const Redis = __importStar(require("ioredis"));
 const namirasoft_log_1 = require("namirasoft-log");
 class RedisInstance {
     constructor(host, port, password, db = 0) {
-        var _a;
-        if (!process.env.NAMIRASOFT_MUTE)
-            this.client = new Redis.Redis({ host, port, password, db });
-        (_a = namirasoft_log_1.Logger.main) === null || _a === void 0 ? void 0 : _a.success(`Redis was connected to: ${host}:${port}`);
+        this.host = host;
+        this.port = port;
+        this.password = password;
+        this.db = db;
         this.close = this.close.bind(this);
     }
     getType() {
@@ -65,6 +65,11 @@ class RedisInstance {
     }
     connect() {
         return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (!process.env.NAMIRASOFT_MUTE) {
+                this.client = new Redis.Redis({ host: this.host, port: this.port, password: this.password, db: this.db });
+                (_a = namirasoft_log_1.Logger.main) === null || _a === void 0 ? void 0 : _a.success(`Redis - ${this.host}:${this.port} - was connected.`);
+            }
         });
     }
     prepare() {
@@ -96,8 +101,11 @@ class RedisInstance {
     }
     close() {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            (_a = this.client) === null || _a === void 0 ? void 0 : _a.disconnect();
+            var _a, _b;
+            if (!process.env.NAMIRASOFT_MUTE) {
+                (_a = this.client) === null || _a === void 0 ? void 0 : _a.disconnect();
+                (_b = namirasoft_log_1.Logger.main) === null || _b === void 0 ? void 0 : _b.success(`Redis - ${this.host}:${this.port} - was closed.`);
+            }
         });
     }
 }

package/dist/RedisInstance.js.map

@@ -1 +1 @@
-{"version":3,"file":"RedisInstance.js","sourceRoot":"","sources":["../src/RedisInstance.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,+CAAiC;AACjC,mDAAwC;AAGxC,MAAsB,aAAa;IAG/B,YAAY,IAAY,EAAE,IAAY,EAAE,QAAgB,EAAE,KAAa,CAAC;;QAEpE,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,eAAe;YAC5B,IAAI,CAAC,MAAM,GAAG,IAAI,KAAK,CAAC,KAAK,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAC,CAAC;QAChE,MAAA,uBAAM,CAAC,IAAI,0CAAE,OAAO,CAAC,2BAA2B,IAAI,IAAI,IAAI,EAAE,CAAC,CAAC;QAChE,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACvC,CAAC;IACD,OAAO;QAEH,OAAO,OAAO,CAAC;IACnB,CAAC;IACD,OAAO;QAEH,OAAO,EAAE,CAAC;IACd,CAAC;IACK,IAAI;;QAEV,CAAC;KAAA;IACK,OAAO;;QAEb,CAAC;KAAA;IACK,OAAO;;QAEb,CAAC;KAAA;IACK,UAAU;;QAEhB,CAAC;KAAA;IACK,SAAS;;QAEf,CAAC;KAAA;IACK,IAAI;;QAEV,CAAC;KAAA;IACK,SAAS;;YAEX,IACA,CAAC;gBACG,IAAI,GAAG,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;gBACnC,OAAO,GAAG,KAAK,MAAM,CAAA;YACzB,CAAC;YAAC,OAAO,KAAK,EACd,CAAC;YACD,CAAC;YACD,OAAO,KAAK,CAAC;QACjB,CAAC;KAAA;IACK,KAAK;;;YAEP,MAAA,IAAI,CAAC,MAAM,0CAAE,UAAU,EAAE,CAAC;QAC9B,CAAC;KAAA;CACJ;AAnDD,sCAmDC;AAAA,CAAC"}
+{"version":3,"file":"RedisInstance.js","sourceRoot":"","sources":["../src/RedisInstance.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,+CAAiC;AACjC,mDAAwC;AAGxC,MAAsB,aAAa;IAG/B,YAAoB,IAAY,EAAU,IAAY,EAAU,QAAgB,EAAU,KAAa,CAAC;QAApF,SAAI,GAAJ,IAAI,CAAQ;QAAU,SAAI,GAAJ,IAAI,CAAQ;QAAU,aAAQ,GAAR,QAAQ,CAAQ;QAAU,OAAE,GAAF,EAAE,CAAY;QAEpG,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACvC,CAAC;IACD,OAAO;QAEH,OAAO,OAAO,CAAC;IACnB,CAAC;IACD,OAAO;QAEH,OAAO,EAAE,CAAC;IACd,CAAC;IACK,IAAI;;QAEV,CAAC;KAAA;IACK,OAAO;;;YAET,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,eAAe,EAChC,CAAC;gBACG,IAAI,CAAC,MAAM,GAAG,IAAI,KAAK,CAAC,KAAK,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE,EAAE,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,CAAC;gBAC1G,MAAA,uBAAM,CAAC,IAAI,0CAAE,OAAO,CAAC,WAAW,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,IAAI,mBAAmB,CAAC,CAAC;YAC/E,CAAC;QACL,CAAC;KAAA;IACK,OAAO;;QAEb,CAAC;KAAA;IACK,UAAU;;QAEhB,CAAC;KAAA;IACK,SAAS;;QAEf,CAAC;KAAA;IACK,IAAI;;QAEV,CAAC;KAAA;IACK,SAAS;;YAEX,IACA,CAAC;gBACG,IAAI,GAAG,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;gBACnC,OAAO,GAAG,KAAK,MAAM,CAAA;YACzB,CAAC;YAAC,OAAO,KAAK,EACd,CAAC;YACD,CAAC;YACD,OAAO,KAAK,CAAC;QACjB,CAAC;KAAA;IACK,KAAK;;;YAEP,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,eAAe,EAChC,CAAC;gBACG,MAAA,IAAI,CAAC,MAAM,0CAAE,UAAU,EAAE,CAAC;gBAC1B,MAAA,uBAAM,CAAC,IAAI,0CAAE,OAAO,CAAC,WAAW,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,IAAI,gBAAgB,CAAC,CAAC;YAC5E,CAAC;QACL,CAAC;KAAA;CACJ;AAzDD,sCAyDC;AAAA,CAAC"}

package/dist/RedisScopeTotalCount.js

@@ -27,22 +27,22 @@ class RedisScopeTotalCount extends RedisScope_1.RedisScope {
             let total_field = this.total.field(field_parameter);
             let count_key = this.count.key(key_parameter);
             let count_field = this.count.field(field_parameter);
-            const script = `
-            local total = tonumber(redis.call("HGET", KEYS[1], ARGV[1]) or "0")
-            local count = tonumber(redis.call("HGET", KEYS[2], ARGV[2]) or "0")
-            local step = tonumber(ARGV[3])
-            local threshold = tonumber(ARGV[4])
-
-            if threshold >= 0 then
-                if total + step > threshold then
-                    return {0, total, count}
-                end
-            end
-
-            total = redis.call("HINCRBY", KEYS[1], ARGV[1], step)
-            count = redis.call("HINCRBY", KEYS[2], ARGV[2], step)
-
-            return {1, total, count}
+            const script = `
+            local total = tonumber(redis.call("HGET", KEYS[1], ARGV[1]) or "0")
+            local count = tonumber(redis.call("HGET", KEYS[2], ARGV[2]) or "0")
+            local step = tonumber(ARGV[3])
+            local threshold = tonumber(ARGV[4])
+
+            if threshold >= 0 then
+                if total + step > threshold then
+                    return {0, total, count}
+                end
+            end
+
+            total = redis.call("HINCRBY", KEYS[1], ARGV[1], step)
+            count = redis.call("HINCRBY", KEYS[2], ARGV[2], step)
+
+            return {1, total, count}
         `;
             let res = yield this.instance.client.eval(script, 2, total_key, count_key, total_field, count_field, step, threshold !== null && threshold !== void 0 ? threshold : -1);
             let [success, total, count] = res;

package/package.json

@@ -1,26 +1,26 @@
-{
-    "name": "namirasoft-node-redis",
-    "title": "Namirasoft Node Redis NPM Package",
-    "description": "Namira Software Corporation Node Redis NPM Package",
-    "icon": "logo.png",
-    "logo": "https://static.namirasoft.com/image/application/redis/logo/base.png",
-    "language": "ts",
-    "framework": "npm",
-    "application": "package",
-    "private": false,
-    "version": "1.4.39",
-    "author": "Amir Abolhasani",
-    "license": "MIT",
-    "main": "./dist/index.js",
-    "types": "./dist/index.d.ts",
-    "scripts": {
-        "build": ""
-    },
-    "dependencies": {
-        "@types/node": "^24.10.1",
-        "ioredis": "^5.8.2",
-        "namirasoft-core": "^1.4.109",
-        "namirasoft-log": "^1.4.41",
-        "namirasoft-node": "^1.4.130"
-    }
+{
+    "name": "namirasoft-node-redis",
+    "title": "Namirasoft Node Redis NPM Package",
+    "description": "Namira Software Corporation Node Redis NPM Package",
+    "icon": "logo.png",
+    "logo": "https://static.namirasoft.com/image/application/redis/logo/base.png",
+    "language": "ts",
+    "framework": "npm",
+    "application": "package",
+    "private": false,
+    "version": "1.4.41",
+    "author": "Amir Abolhasani",
+    "license": "MIT",
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "scripts": {
+        "build": ""
+    },
+    "dependencies": {
+        "@types/node": "^25.2.3",
+        "ioredis": "^5.9.3",
+        "namirasoft-core": "^1.4.111",
+        "namirasoft-log": "^1.4.41",
+        "namirasoft-node": "^1.4.135"
+    }
 }

package/src/RedisInstance.ts

@@ -1,56 +1,62 @@
-import * as Redis from "ioredis";
-import { Logger } from "namirasoft-log";
-import { IDatabase } from "namirasoft-node";
-
-export abstract class RedisInstance implements IDatabase
-{
-    public client!: Redis.Redis;
-    constructor(host: string, port: number, password: string, db: number = 0)
-    {
-        if (!process.env.NAMIRASOFT_MUTE)
-            this.client = new Redis.Redis({ host, port, password, db });
-        Logger.main?.success(`Redis was connected to: ${host}:${port}`);
-        this.close = this.close.bind(this);
-    }
-    getType()
-    {
-        return "Redis";
-    }
-    getName()
-    {
-        return "";
-    }
-    async init()
-    {
-    }
-    async connect()
-    {
-    }
-    async prepare()
-    {
-    }
-    async seedBefore()
-    {
-    }
-    async seedAfter()
-    {
-    }
-    async sync()
-    {
-    }
-    async isHealthy()
-    {
-        try
-        {
-            let res = await this.client.ping();
-            return res === "PONG"
-        } catch (error)
-        {
-        }
-        return false;
-    }
-    async close()
-    {
-        this.client?.disconnect();
-    }
+import * as Redis from "ioredis";
+import { Logger } from "namirasoft-log";
+import { IDatabase } from "namirasoft-node";
+
+export abstract class RedisInstance implements IDatabase
+{
+    public client!: Redis.Redis;
+    constructor(private host: string, private port: number, private password: string, private db: number = 0)
+    {
+        this.close = this.close.bind(this);
+    }
+    getType()
+    {
+        return "Redis";
+    }
+    getName()
+    {
+        return "";
+    }
+    async init()
+    {
+    }
+    async connect()
+    {
+        if (!process.env.NAMIRASOFT_MUTE)
+        {
+            this.client = new Redis.Redis({ host: this.host, port: this.port, password: this.password, db: this.db });
+            Logger.main?.success(`Redis - ${this.host}:${this.port} - was connected.`);
+        }
+    }
+    async prepare()
+    {
+    }
+    async seedBefore()
+    {
+    }
+    async seedAfter()
+    {
+    }
+    async sync()
+    {
+    }
+    async isHealthy()
+    {
+        try
+        {
+            let res = await this.client.ping();
+            return res === "PONG"
+        } catch (error)
+        {
+        }
+        return false;
+    }
+    async close()
+    {
+        if (!process.env.NAMIRASOFT_MUTE)
+        {
+            this.client?.disconnect();
+            Logger.main?.success(`Redis - ${this.host}:${this.port} - was closed.`);
+        }
+    }
 };

package/src/RedisScope.ts

@@ -1,55 +1,55 @@
-import { EncodingOperation } from "namirasoft-core";
-import { RedisInstance } from "./RedisInstance";
-
-export abstract class RedisScope<KeyParameters, ValueType>
-{
-    protected instance: RedisInstance;
-    constructor(instance: RedisInstance)
-    {
-        this.instance = instance;
-        this.key = this.key.bind(this);
-        this._get = this._get.bind(this);
-        this._set = this._set.bind(this);
-        this._del = this._del.bind(this);
-    }
-    public abstract key(key_parameter: KeyParameters): string;
-    protected async _get(key: string, base64: boolean): Promise<ValueType | null>
-    {
-        if (process.env.NAMIRASOFT_MUTE)
-            return null;
-        let data = await this.instance.client.get(key);
-        if (data)
-        {
-            if (base64)
-                data = EncodingOperation.Base64Decode(data);
-            return JSON.parse(data) as ValueType;
-        }
-        return null;
-    }
-    protected async _set(key: string, value: ValueType, base64: boolean, ttl_seconds?: number, NotExists: boolean = false)
-    {
-        if (process.env.NAMIRASOFT_MUTE)
-            return null;
-        let data = JSON.stringify(value);
-        if (base64)
-            data = EncodingOperation.Base64Encode(data);
-        if (NotExists)
-        {
-            if (ttl_seconds)
-                return await this.instance.client.set(key, data, "EX", ttl_seconds, "NX");
-            return await this.instance.client.set(key, data, "NX");
-        }
-        else 
-        {
-            if (ttl_seconds)
-                return await this.instance.client.set(key, data, "EX", ttl_seconds);
-            return await this.instance.client.set(key, data);
-        }
-    }
-    protected async _del(key: string)
-    {
-        if (process.env.NAMIRASOFT_MUTE)
-            return;
-        await this.instance.client.del(key);
-    }
+import { EncodingOperation } from "namirasoft-core";
+import { RedisInstance } from "./RedisInstance";
+
+export abstract class RedisScope<KeyParameters, ValueType>
+{
+    protected instance: RedisInstance;
+    constructor(instance: RedisInstance)
+    {
+        this.instance = instance;
+        this.key = this.key.bind(this);
+        this._get = this._get.bind(this);
+        this._set = this._set.bind(this);
+        this._del = this._del.bind(this);
+    }
+    public abstract key(key_parameter: KeyParameters): string;
+    protected async _get(key: string, base64: boolean): Promise<ValueType | null>
+    {
+        if (process.env.NAMIRASOFT_MUTE)
+            return null;
+        let data = await this.instance.client.get(key);
+        if (data)
+        {
+            if (base64)
+                data = EncodingOperation.Base64Decode(data);
+            return JSON.parse(data) as ValueType;
+        }
+        return null;
+    }
+    protected async _set(key: string, value: ValueType, base64: boolean, ttl_seconds?: number, NotExists: boolean = false)
+    {
+        if (process.env.NAMIRASOFT_MUTE)
+            return null;
+        let data = JSON.stringify(value);
+        if (base64)
+            data = EncodingOperation.Base64Encode(data);
+        if (NotExists)
+        {
+            if (ttl_seconds)
+                return await this.instance.client.set(key, data, "EX", ttl_seconds, "NX");
+            return await this.instance.client.set(key, data, "NX");
+        }
+        else 
+        {
+            if (ttl_seconds)
+                return await this.instance.client.set(key, data, "EX", ttl_seconds);
+            return await this.instance.client.set(key, data);
+        }
+    }
+    protected async _del(key: string)
+    {
+        if (process.env.NAMIRASOFT_MUTE)
+            return;
+        await this.instance.client.del(key);
+    }
 };

package/src/RedisScopeDelay.ts

@@ -1,56 +1,56 @@
-import { DurationUnit, TimeUnitOperation } from "namirasoft-core";
-import { RedisInstance } from "./RedisInstance";
-import { RedisScope } from "./RedisScope";
-import { RedisScopeLock } from "./RedisScopeLock";
-
-export type RedisScopeDelayParameter = {
-    id: string;
-    delay: boolean;
-    delay_value: number | null;
-    delay_unit: DurationUnit | null;
-};
-
-export abstract class RedisScopeDelay<KeyParameters> extends RedisScope<KeyParameters, Date>
-{
-    private locker: RedisScopeLock<KeyParameters>;
-    private max_processing_time_in_seconds: number;
-    constructor(instance: RedisInstance, locker: RedisScopeLock<KeyParameters>, max_processing_time_in_seconds: number = 60)
-    {
-        super(instance);
-        this.locker = locker;
-        this.max_processing_time_in_seconds = max_processing_time_in_seconds;
-        this.wait = this.wait.bind(this);
-        this.release = this.release.bind(this);
-    }
-    async wait(key_parameter: KeyParameters, parameter: RedisScopeDelayParameter): Promise<void>
-    {
-        if (!parameter.delay || !parameter.delay_value || !parameter.delay_unit)
-            return;
-
-        let key = this.key(key_parameter);
-
-        let delay_requested = TimeUnitOperation.toMilliseconds(parameter.delay_value, parameter.delay_unit);
-        let ttl_seconds = Math.ceil(delay_requested / 1000) + this.max_processing_time_in_seconds;
-        await this.locker.waitForLock(key_parameter, ttl_seconds);
-
-        let LastRun = await this._get(key, false);
-        if (!LastRun)
-            return;
-        LastRun = new Date(LastRun);
-
-        let difference = new Date().getTime() - LastRun.getTime();
-        let delay_required = Math.max(delay_requested - difference, 0);
-
-        if (delay_required > 0)
-            await new Promise(resolve => setTimeout(resolve, delay_required));
-    }
-    async release(key_parameter: KeyParameters, parameter: RedisScopeDelayParameter)
-    {
-        if (!parameter.delay || !parameter.delay_value || !parameter.delay_unit)
-            return;
-
-        let key = this.key(key_parameter);
-        await this._set(key, new Date(), false);
-        await this.locker.unlock(key_parameter);
-    }
+import { DurationUnit, TimeUnitOperation } from "namirasoft-core";
+import { RedisInstance } from "./RedisInstance";
+import { RedisScope } from "./RedisScope";
+import { RedisScopeLock } from "./RedisScopeLock";
+
+export type RedisScopeDelayParameter = {
+    id: string;
+    delay: boolean;
+    delay_value: number | null;
+    delay_unit: DurationUnit | null;
+};
+
+export abstract class RedisScopeDelay<KeyParameters> extends RedisScope<KeyParameters, Date>
+{
+    private locker: RedisScopeLock<KeyParameters>;
+    private max_processing_time_in_seconds: number;
+    constructor(instance: RedisInstance, locker: RedisScopeLock<KeyParameters>, max_processing_time_in_seconds: number = 60)
+    {
+        super(instance);
+        this.locker = locker;
+        this.max_processing_time_in_seconds = max_processing_time_in_seconds;
+        this.wait = this.wait.bind(this);
+        this.release = this.release.bind(this);
+    }
+    async wait(key_parameter: KeyParameters, parameter: RedisScopeDelayParameter): Promise<void>
+    {
+        if (!parameter.delay || !parameter.delay_value || !parameter.delay_unit)
+            return;
+
+        let key = this.key(key_parameter);
+
+        let delay_requested = TimeUnitOperation.toMilliseconds(parameter.delay_value, parameter.delay_unit);
+        let ttl_seconds = Math.ceil(delay_requested / 1000) + this.max_processing_time_in_seconds;
+        await this.locker.waitForLock(key_parameter, ttl_seconds);
+
+        let LastRun = await this._get(key, false);
+        if (!LastRun)
+            return;
+        LastRun = new Date(LastRun);
+
+        let difference = new Date().getTime() - LastRun.getTime();
+        let delay_required = Math.max(delay_requested - difference, 0);
+
+        if (delay_required > 0)
+            await new Promise(resolve => setTimeout(resolve, delay_required));
+    }
+    async release(key_parameter: KeyParameters, parameter: RedisScopeDelayParameter)
+    {
+        if (!parameter.delay || !parameter.delay_value || !parameter.delay_unit)
+            return;
+
+        let key = this.key(key_parameter);
+        await this._set(key, new Date(), false);
+        await this.locker.unlock(key_parameter);
+    }
 };

package/src/RedisScopeHashCounter.ts

@@ -1,56 +1,56 @@
-import { RedisInstance } from "./RedisInstance";
-import { RedisScope } from "./RedisScope";
-
-export abstract class RedisScopeHashCounter<KeyParameters, FieldParameters> extends RedisScope<KeyParameters | null, Date>
-{
-    constructor(instance: RedisInstance)
-    {
-        super(instance);
-        this.increase = this.increase.bind(this);
-        this.listKeys = this.listKeys.bind(this);
-        this.listFields = this.listFields.bind(this);
-        this.del = this.del.bind(this);
-    }
-    public abstract field(field_parameter: FieldParameters): string;
-    async valid(key_parameter: KeyParameters, field_parameter: FieldParameters, threshold: number, step: number): Promise<boolean>
-    {
-        let count = await this.hget(key_parameter, field_parameter);
-        return count + step <= threshold;
-    }
-    async increase(key_parameter: KeyParameters, field_parameter: FieldParameters, step: number): Promise<number>
-    {
-        let key = this.key(key_parameter);
-        let field = this.field(field_parameter);
-        return await this.instance.client.hincrby(key, field, step);
-    }
-    async hget(key_parameter: KeyParameters, field_parameter: FieldParameters): Promise<number>
-    {
-        let key = this.key(key_parameter);
-        let field = this.field(field_parameter);
-        let res = await this.instance.client.hget(key, field) ?? "0";
-        return parseInt(res);
-    }
-    async listKeys(count: number = 1, cursor?: string | number): Promise<{ cursor: string | number, keys: string[] }>
-    {
-        if (cursor == null)
-            cursor = "0";
-        let [next, keys] = await this.instance.client.scan(cursor, "MATCH", this.key(null), "COUNT", count,);
-        return { keys, cursor: next };
-    }
-    async listFields(key_parameter: KeyParameters)
-    {
-        let key = this.key(key_parameter);
-        return await this.instance.client.hgetall(key);
-    }
-    async delField(key_parameter: KeyParameters, field_parameter: FieldParameters)
-    {
-        let key = this.key(key_parameter);
-        let field = this.field(field_parameter);
-        return await this.instance.client.hdel(key, field);
-    }
-    async del(key_parameter: KeyParameters)
-    {
-        let key = this.key(key_parameter);
-        return await this._del(key);
-    }
+import { RedisInstance } from "./RedisInstance";
+import { RedisScope } from "./RedisScope";
+
+export abstract class RedisScopeHashCounter<KeyParameters, FieldParameters> extends RedisScope<KeyParameters | null, Date>
+{
+    constructor(instance: RedisInstance)
+    {
+        super(instance);
+        this.increase = this.increase.bind(this);
+        this.listKeys = this.listKeys.bind(this);
+        this.listFields = this.listFields.bind(this);
+        this.del = this.del.bind(this);
+    }
+    public abstract field(field_parameter: FieldParameters): string;
+    async valid(key_parameter: KeyParameters, field_parameter: FieldParameters, threshold: number, step: number): Promise<boolean>
+    {
+        let count = await this.hget(key_parameter, field_parameter);
+        return count + step <= threshold;
+    }
+    async increase(key_parameter: KeyParameters, field_parameter: FieldParameters, step: number): Promise<number>
+    {
+        let key = this.key(key_parameter);
+        let field = this.field(field_parameter);
+        return await this.instance.client.hincrby(key, field, step);
+    }
+    async hget(key_parameter: KeyParameters, field_parameter: FieldParameters): Promise<number>
+    {
+        let key = this.key(key_parameter);
+        let field = this.field(field_parameter);
+        let res = await this.instance.client.hget(key, field) ?? "0";
+        return parseInt(res);
+    }
+    async listKeys(count: number = 1, cursor?: string | number): Promise<{ cursor: string | number, keys: string[] }>
+    {
+        if (cursor == null)
+            cursor = "0";
+        let [next, keys] = await this.instance.client.scan(cursor, "MATCH", this.key(null), "COUNT", count,);
+        return { keys, cursor: next };
+    }
+    async listFields(key_parameter: KeyParameters)
+    {
+        let key = this.key(key_parameter);
+        return await this.instance.client.hgetall(key);
+    }
+    async delField(key_parameter: KeyParameters, field_parameter: FieldParameters)
+    {
+        let key = this.key(key_parameter);
+        let field = this.field(field_parameter);
+        return await this.instance.client.hdel(key, field);
+    }
+    async del(key_parameter: KeyParameters)
+    {
+        let key = this.key(key_parameter);
+        return await this._del(key);
+    }
 };

package/src/RedisScopeLimit.ts

@@ -1,61 +1,61 @@
-import { DurationUnit, TimeOperation, TimeUnitOperation } from "namirasoft-core";
-import { RedisInstance } from "./RedisInstance";
-import { RedisScope } from "./RedisScope";
-
-export type RedisScopeLimitParameter = {
-    id: string;
-    name: string;
-    limit: boolean;
-    limit_count: number | null;
-    limit_per_value: number | null;
-    limit_per_unit: DurationUnit | null;
-};
-
-export abstract class RedisScopeLimit<KeyParameters> extends RedisScope<KeyParameters, number>
-{
-    constructor(instance: RedisInstance)
-    {
-        super(instance);
-        this.getCount = this.getCount.bind(this);
-        this.add = this.add.bind(this);
-        this.del = this.del.bind(this);
-    }
-    async getCount(key_parameter: KeyParameters, limit_per_value: number, limit_per_unit: DurationUnit): Promise<number>
-    {
-        let key = this.key(key_parameter);
-
-        let milliseconds = TimeUnitOperation.toMilliseconds(limit_per_value, limit_per_unit);
-        let date_finish = new Date();
-        let date_start = TimeOperation.millisecondsAgo(milliseconds, date_finish);
-
-        return await this.instance.client.zcount(key, date_start.getTime(), date_finish.getTime());
-    }
-    async add(key_parameter: KeyParameters, limit_per_value: number, limit_per_unit: DurationUnit)
-    {
-        let key = this.key(key_parameter);
-
-        let milliseconds = TimeUnitOperation.toMilliseconds(limit_per_value, limit_per_unit);
-        let date_finish = new Date();
-        let date_start = TimeOperation.millisecondsAgo(milliseconds, date_finish)
-
-        await this.instance.client.zadd(key, date_finish.getTime(), date_finish.getTime());
-        await this.instance.client.zremrangebyscore(key, 0, date_start.getTime());
-    }
-    async del(key_parameter: KeyParameters)
-    {
-        let key = this.key(key_parameter);
-        await this._del(key);
-    }
-    async check(key_parameter: KeyParameters, parameter: RedisScopeLimitParameter)
-    {
-        if (parameter.limit)
-            if (parameter.limit_count && parameter.limit_per_value && parameter.limit_per_unit)
-            {
-                let count = await this.getCount(key_parameter, parameter.limit_per_value, parameter.limit_per_unit);
-                if (count < parameter.limit_count)
-                    await this.add(key_parameter, parameter.limit_per_value, parameter.limit_per_unit);
-                else
-                    throw new Error(`Limit has reached for '${parameter.name}' '${parameter.id}' for ${parameter.limit_count} messages every ${parameter.limit_per_value} ${parameter.limit_per_unit}`);
-            }
-    }
+import { DurationUnit, TimeOperation, TimeUnitOperation } from "namirasoft-core";
+import { RedisInstance } from "./RedisInstance";
+import { RedisScope } from "./RedisScope";
+
+export type RedisScopeLimitParameter = {
+    id: string;
+    name: string;
+    limit: boolean;
+    limit_count: number | null;
+    limit_per_value: number | null;
+    limit_per_unit: DurationUnit | null;
+};
+
+export abstract class RedisScopeLimit<KeyParameters> extends RedisScope<KeyParameters, number>
+{
+    constructor(instance: RedisInstance)
+    {
+        super(instance);
+        this.getCount = this.getCount.bind(this);
+        this.add = this.add.bind(this);
+        this.del = this.del.bind(this);
+    }
+    async getCount(key_parameter: KeyParameters, limit_per_value: number, limit_per_unit: DurationUnit): Promise<number>
+    {
+        let key = this.key(key_parameter);
+
+        let milliseconds = TimeUnitOperation.toMilliseconds(limit_per_value, limit_per_unit);
+        let date_finish = new Date();
+        let date_start = TimeOperation.millisecondsAgo(milliseconds, date_finish);
+
+        return await this.instance.client.zcount(key, date_start.getTime(), date_finish.getTime());
+    }
+    async add(key_parameter: KeyParameters, limit_per_value: number, limit_per_unit: DurationUnit)
+    {
+        let key = this.key(key_parameter);
+
+        let milliseconds = TimeUnitOperation.toMilliseconds(limit_per_value, limit_per_unit);
+        let date_finish = new Date();
+        let date_start = TimeOperation.millisecondsAgo(milliseconds, date_finish)
+
+        await this.instance.client.zadd(key, date_finish.getTime(), date_finish.getTime());
+        await this.instance.client.zremrangebyscore(key, 0, date_start.getTime());
+    }
+    async del(key_parameter: KeyParameters)
+    {
+        let key = this.key(key_parameter);
+        await this._del(key);
+    }
+    async check(key_parameter: KeyParameters, parameter: RedisScopeLimitParameter)
+    {
+        if (parameter.limit)
+            if (parameter.limit_count && parameter.limit_per_value && parameter.limit_per_unit)
+            {
+                let count = await this.getCount(key_parameter, parameter.limit_per_value, parameter.limit_per_unit);
+                if (count < parameter.limit_count)
+                    await this.add(key_parameter, parameter.limit_per_value, parameter.limit_per_unit);
+                else
+                    throw new Error(`Limit has reached for '${parameter.name}' '${parameter.id}' for ${parameter.limit_count} messages every ${parameter.limit_per_value} ${parameter.limit_per_unit}`);
+            }
+    }
 };

package/src/RedisScopeLock.ts

@@ -1,33 +1,33 @@
-import { RedisInstance } from "./RedisInstance";
-import { RedisScope } from "./RedisScope";
-
-export abstract class RedisScopeLock<KeyParameters> extends RedisScope<KeyParameters, number>
-{
-    constructor(instance: RedisInstance, private ttl_seconds: number)
-    {
-        super(instance);
-        this.lock = this.lock.bind(this);
-        this.waitForLock = this.waitForLock.bind(this);
-        this.unlock = this.unlock.bind(this);
-    }
-    async lock(key_parameter: KeyParameters, ttl_seconds?: number): Promise<boolean>
-    {
-        let time = ttl_seconds ?? this.ttl_seconds;
-        let ans = await this._set(this.key(key_parameter), Math.random(), true, time, true);
-        return ans === "OK";
-    }
-    async waitForLock(key_parameter: KeyParameters, ttl_seconds?: number): Promise<void>
-    {
-        while (true)
-        {
-            let ans = await this.lock(key_parameter, ttl_seconds);
-            if (ans)
-                break;
-            await new Promise(res => setTimeout(res, 10));
-        }
-    }
-    async unlock(key_parameter: KeyParameters)
-    {
-        await this._del(this.key(key_parameter));
-    }
+import { RedisInstance } from "./RedisInstance";
+import { RedisScope } from "./RedisScope";
+
+export abstract class RedisScopeLock<KeyParameters> extends RedisScope<KeyParameters, number>
+{
+    constructor(instance: RedisInstance, private ttl_seconds: number)
+    {
+        super(instance);
+        this.lock = this.lock.bind(this);
+        this.waitForLock = this.waitForLock.bind(this);
+        this.unlock = this.unlock.bind(this);
+    }
+    async lock(key_parameter: KeyParameters, ttl_seconds?: number): Promise<boolean>
+    {
+        let time = ttl_seconds ?? this.ttl_seconds;
+        let ans = await this._set(this.key(key_parameter), Math.random(), true, time, true);
+        return ans === "OK";
+    }
+    async waitForLock(key_parameter: KeyParameters, ttl_seconds?: number): Promise<void>
+    {
+        while (true)
+        {
+            let ans = await this.lock(key_parameter, ttl_seconds);
+            if (ans)
+                break;
+            await new Promise(res => setTimeout(res, 10));
+        }
+    }
+    async unlock(key_parameter: KeyParameters)
+    {
+        await this._del(this.key(key_parameter));
+    }
 };

package/src/RedisScopeShardCoordinator.ts

@@ -1,39 +1,39 @@
-import { BaseUUID } from "namirasoft-core";
-import { RedisInstance } from "./RedisInstance";
-import { RedisScope } from "./RedisScope";
-
-export abstract class RedisScopeShardCoordinator extends RedisScope<void, number>
-{
-    protected id: string;
-    constructor(instance: RedisInstance, private ttl_seconds: number)
-    {
-        super(instance);
-        this.id = `${new Date().getTime()}-${BaseUUID.uuid(5)}`;
-    }
-    async heartbeat(ttl_seconds?: number): Promise<void>
-    {
-        const ttl = ttl_seconds ?? this.ttl_seconds;
-        const key = this.key();
-        const key_instance = `${key}:${this.id}`;
-        await this.instance.client.set(key_instance, "1", "EX", ttl);
-    }
-    async get(ttl_seconds?: number): Promise<{
-        id: string,
-        index: number,
-        total: number
-    }>
-    {
-        await this.heartbeat(ttl_seconds);
-
-        const key = this.key();
-        const pattern = `${key}:*`;
-
-        const keys = await this.instance.client.keys(pattern);
-        keys.sort();
-
-        const index = keys.indexOf(`${key}:${this.id}`);
-        const total = keys.length;
-
-        return { id: this.id, index, total };
-    }
+import { BaseUUID } from "namirasoft-core";
+import { RedisInstance } from "./RedisInstance";
+import { RedisScope } from "./RedisScope";
+
+export abstract class RedisScopeShardCoordinator extends RedisScope<void, number>
+{
+    protected id: string;
+    constructor(instance: RedisInstance, private ttl_seconds: number)
+    {
+        super(instance);
+        this.id = `${new Date().getTime()}-${BaseUUID.uuid(5)}`;
+    }
+    async heartbeat(ttl_seconds?: number): Promise<void>
+    {
+        const ttl = ttl_seconds ?? this.ttl_seconds;
+        const key = this.key();
+        const key_instance = `${key}:${this.id}`;
+        await this.instance.client.set(key_instance, "1", "EX", ttl);
+    }
+    async get(ttl_seconds?: number): Promise<{
+        id: string,
+        index: number,
+        total: number
+    }>
+    {
+        await this.heartbeat(ttl_seconds);
+
+        const key = this.key();
+        const pattern = `${key}:*`;
+
+        const keys = await this.instance.client.keys(pattern);
+        keys.sort();
+
+        const index = keys.indexOf(`${key}:${this.id}`);
+        const total = keys.length;
+
+        return { id: this.id, index, total };
+    }
 };

package/src/RedisScopeTotalCount.ts

@@ -1,46 +1,46 @@
-import { RedisInstance } from "./RedisInstance";
-import { RedisScope } from "./RedisScope";
-import { RedisScopeHashCounter } from "./RedisScopeHashCounter";
-
-export class RedisScopeTotalCount<KeyParameters, FieldParameters> extends RedisScope<null, Date>
-{
-    constructor(instance: RedisInstance,
-        public total: RedisScopeHashCounter<KeyParameters, FieldParameters>,
-        public count: RedisScopeHashCounter<KeyParameters, FieldParameters>)
-    {
-        super(instance);
-        this.increase = this.increase.bind(this);
-    }
-    override key(): string
-    {
-        return "";
-    }
-    async increase(key_parameter: KeyParameters, field_parameter: FieldParameters, step: number, threshold: number | null): Promise<{ success: boolean, total: number, count: number }>
-    {
-        let total_key = this.total.key(key_parameter);
-        let total_field = this.total.field(field_parameter);
-        let count_key = this.count.key(key_parameter);
-        let count_field = this.count.field(field_parameter);
-
-        const script = `
-            local total = tonumber(redis.call("HGET", KEYS[1], ARGV[1]) or "0")
-            local count = tonumber(redis.call("HGET", KEYS[2], ARGV[2]) or "0")
-            local step = tonumber(ARGV[3])
-            local threshold = tonumber(ARGV[4])
-
-            if threshold >= 0 then
-                if total + step > threshold then
-                    return {0, total, count}
-                end
-            end
-
-            total = redis.call("HINCRBY", KEYS[1], ARGV[1], step)
-            count = redis.call("HINCRBY", KEYS[2], ARGV[2], step)
-
-            return {1, total, count}
-        `;
-        let res = await this.instance.client.eval(script, 2, total_key, count_key, total_field, count_field, step, threshold ?? -1);
-        let [success, total, count] = res as number[];
-        return { success: success == 1, total, count };
-    }
+import { RedisInstance } from "./RedisInstance";
+import { RedisScope } from "./RedisScope";
+import { RedisScopeHashCounter } from "./RedisScopeHashCounter";
+
+export class RedisScopeTotalCount<KeyParameters, FieldParameters> extends RedisScope<null, Date>
+{
+    constructor(instance: RedisInstance,
+        public total: RedisScopeHashCounter<KeyParameters, FieldParameters>,
+        public count: RedisScopeHashCounter<KeyParameters, FieldParameters>)
+    {
+        super(instance);
+        this.increase = this.increase.bind(this);
+    }
+    override key(): string
+    {
+        return "";
+    }
+    async increase(key_parameter: KeyParameters, field_parameter: FieldParameters, step: number, threshold: number | null): Promise<{ success: boolean, total: number, count: number }>
+    {
+        let total_key = this.total.key(key_parameter);
+        let total_field = this.total.field(field_parameter);
+        let count_key = this.count.key(key_parameter);
+        let count_field = this.count.field(field_parameter);
+
+        const script = `
+            local total = tonumber(redis.call("HGET", KEYS[1], ARGV[1]) or "0")
+            local count = tonumber(redis.call("HGET", KEYS[2], ARGV[2]) or "0")
+            local step = tonumber(ARGV[3])
+            local threshold = tonumber(ARGV[4])
+
+            if threshold >= 0 then
+                if total + step > threshold then
+                    return {0, total, count}
+                end
+            end
+
+            total = redis.call("HINCRBY", KEYS[1], ARGV[1], step)
+            count = redis.call("HINCRBY", KEYS[2], ARGV[2], step)
+
+            return {1, total, count}
+        `;
+        let res = await this.instance.client.eval(script, 2, total_key, count_key, total_field, count_field, step, threshold ?? -1);
+        let [success, total, count] = res as number[];
+        return { success: success == 1, total, count };
+    }
 };

package/src/RedisScopeUniqueness.ts

@@ -1,30 +1,30 @@
-import { RedisInstance } from "./RedisInstance";
-import { RedisScope } from "./RedisScope";
-
-export abstract class RedisScopeUniqueness<KeyParameters> extends RedisScope<KeyParameters, number>
-{
-    constructor(instance: RedisInstance, private ttl_seconds: number)
-    {
-        super(instance);
-        this.set = this.set.bind(this);
-        this.exists = this.exists.bind(this);
-    }
-    async set(key_parameter: KeyParameters, ttl_seconds?: number): Promise<boolean>
-    {
-        const ttl = ttl_seconds ?? this.ttl_seconds;
-        const ans = await this._set(this.key(key_parameter), Math.random(), true, ttl, true);
-        return ans === "OK";
-    }
-    async exists(key_parameter: KeyParameters): Promise<boolean>
-    {
-        const key = this.key(key_parameter);
-        const exists = await this.instance.client.exists(key);
-
-        return exists != 0;
-    }
-    async del(key_parameter: KeyParameters): Promise<void>
-    {
-        const key = this.key(key_parameter);
-        this._del(key);
-    }
+import { RedisInstance } from "./RedisInstance";
+import { RedisScope } from "./RedisScope";
+
+export abstract class RedisScopeUniqueness<KeyParameters> extends RedisScope<KeyParameters, number>
+{
+    constructor(instance: RedisInstance, private ttl_seconds: number)
+    {
+        super(instance);
+        this.set = this.set.bind(this);
+        this.exists = this.exists.bind(this);
+    }
+    async set(key_parameter: KeyParameters, ttl_seconds?: number): Promise<boolean>
+    {
+        const ttl = ttl_seconds ?? this.ttl_seconds;
+        const ans = await this._set(this.key(key_parameter), Math.random(), true, ttl, true);
+        return ans === "OK";
+    }
+    async exists(key_parameter: KeyParameters): Promise<boolean>
+    {
+        const key = this.key(key_parameter);
+        const exists = await this.instance.client.exists(key);
+
+        return exists != 0;
+    }
+    async del(key_parameter: KeyParameters): Promise<void>
+    {
+        const key = this.key(key_parameter);
+        this._del(key);
+    }
 };

package/src/index.ts

@@ -1,9 +1,9 @@
-export * from "./RedisInstance";
-export * from "./RedisScope";
-export * from "./RedisScopeDelay";
-export * from "./RedisScopeHashCounter";
-export * from "./RedisScopeLimit";
-export * from "./RedisScopeLock";
-export * from "./RedisScopeShardCoordinator";
-export * from "./RedisScopeTotalCount";
+export * from "./RedisInstance";
+export * from "./RedisScope";
+export * from "./RedisScopeDelay";
+export * from "./RedisScopeHashCounter";
+export * from "./RedisScopeLimit";
+export * from "./RedisScopeLock";
+export * from "./RedisScopeShardCoordinator";
+export * from "./RedisScopeTotalCount";
 export * from "./RedisScopeUniqueness";