@samet-it/be-redis-common 1.1.1

package/LICENSE

@@ -0,0 +1,24 @@
+MIT License
+
+Copyright (c) 2025 Samet Global
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+Web: https://sametglobal.com
+Responsible: Mustafa Yelmer (mustafay@samet.com.tr)

package/README.md

@@ -0,0 +1,89 @@
+# Samet IT : Redis Common
+`ts` `component` `backend`
+```
+                  ___                                                  
+   ________  ____/ (______   _________  ____ ___  ____ ___  ____  ____ 
+  / ___/ _ \/ __  / / ___/  / ___/ __ \/ __ `__ \/ __ `__ \/ __ \/ __ \
+ / /  /  __/ /_/ / (__  )  / /__/ /_/ / / / / / / / / / / / /_/ / / / /
+/_/   \___/\__,_/_/____/   \___/\____/_/ /_/ /_/_/ /_/ /_/\____/_/ /_/ 
+```
+<!-- https://patorjk.com/software/taag/#p=display&f=Slant&t=redis+common&x=none&v=4&h=3&w=80&we=false -->
+- `EN`: Use it for redis connections
+- `TR`: Redis (cache) bağlantıları için bu bileşeni kullanınız
+
+## Prerequisite
+- [Help](https://github.com/samet-digital/help)
+- [1 - Install Git](https://github.com/samet-digital/help/blob/main//install-git.MD)
+- [2 - Build Up a Git Connection](https://github.com/samet-digital/help/blob/main//build-git-connection.MD)
+- [3 - Install Node/NPM](https://github.com/samet-digital/help/blob/main//install-npm.MD)
+- [4 - Create Project Folder](https://github.com/samet-digital/help/blob/main//create-project-folder.MD)
+- [5 - Bind Projects Folder to Git](https://github.com/samet-digital/help/blob/main//bind-project-folder.MD)
+
+## Usage
+- `EN`: How to add into your project?
+- `TR`: Projene nasıl eklersin?
+
+```shell
+npm i @samet-it/be-redis-common
+```
+
+## Environments
+- [RedisCommonConf](./src/config/redis-common.config.ts)
+
+| Name              | Type    | Default | Required | Secret | Description              |
+|-------------------|---------|---------|----------|--------|--------------------------|
+| `REDIS_HOST`      | string  |         | ✅        | ⭕      | Redis Host or IP Address |
+| `REDIS_PORT`      | integer | _6379_  | ✅        | ⭕      | Redis port               |
+| `REDIS_USER`      | string  |         |          | ⭕      | Redis User               |
+| `REDIS_PASS`      | string  |         |          | ⭕      | Redis Password           |
+| `REDIS_PREFIX`    | string  |         |          |        | Prefix for keys          |
+| `REDIS_DB_NUMBER` | integer |         |          |        | Redis DB number          |
+
+## Contents
+- `abstract` [RedisConnection](src/connection/redis.connection.ts) - abstract connection class
+- `class` [RedisDirectConnection](src/connection/redis-direct.connection.ts) - Direct connection class 
+- `function` [redisConnection()](src/connection/redis-connection.fn.ts) - Direct connection function
+- `abstract` [RedisChannel](src/channel/redis.channel.ts) - abstract repository
+- `class` [RedisDirectChannel](src/channel/redis-direct.channel.ts) - direct repository
+
+
+## Development
+> You can start to develop on it
+>
+### Step 1
+- [Go to project folder](https://github.com/samet-digital/help/blob/main/go-to-project-folder.MD)
+
+### Step 2
+- `EN`: Clone the project
+- `TR`: Projeyi bilgisiyarına çek
+```shell
+git clone https://github.com/samet-digital/be-redis-common.git -b development
+```
+
+## Dependencies
+- `@samet-it/be-base-common`:  **samet** base common
+- `@samet-it/be-cache-common`:  **samet** cache common
+- `@leyyo/*`: leyyo utilities
+- `@nestjs/*`: nestjs framework
+- `redis`: redis client
+
+## Commands
+- [Component Commands](https://github.com/samet-digital/help/blob/main/commands-component.MD)
+
+## Standards
+```diff
++ language: TS 
++ lint: eslint
++ inspections: intelli-j code inspections
++ ddd: domain driven development
++ edd: exception driven development
+! tdd: test driven development
++ ldd: log driven development
++ ddd: document driven development
+```
+
+## History
+| Date       | Developer      | Info         | Ticket                  |
+|------------|----------------|--------------|-------------------------|
+| 2025-08-13 | Mustafa Yelmer | _Created_    | ~~[none](./README.md)~~ |
+| 2026-01-11 | Mustafa Yelmer | _Refactored_ | ~~[none](./README.md)~~ |

package/dist/channel/index.d.ts

@@ -0,0 +1,3 @@
+export * from './index.types';
+export * from './redis.channel';
+export * from './redis-direct.channel';

package/dist/channel/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./index.types"), exports);
+__exportStar(require("./redis.channel"), exports);
+__exportStar(require("./redis-direct.channel"), exports);

package/dist/channel/index.types.d.ts

@@ -0,0 +1,39 @@
+import type { RedisConnectionLike } from "../connection";
+import type { CacheChannelProps, CacheChannelLike, CacheChannelOpt } from "@samet-it/be-cache-common";
+import type { Entity } from "@samet-it/be-base-common";
+import type { RedisClientType } from "redis";
+import type { KeyValue } from "@leyyo/common";
+/**
+ * Redis channel interface
+ * */
+export interface RedisChannelLike<ID extends KeyValue, ENTITY extends Entity<ID>> extends CacheChannelLike<RedisConnectionLike, ID, ENTITY> {
+    /** @inheritDoc */
+    get props(): Readonly<RedisChannelProps>;
+}
+/**
+ * Redis channel option
+ * */
+export interface RedisChannelOpt extends CacheChannelOpt {
+}
+/**
+ * Redis channel props
+ * */
+export interface RedisChannelProps extends CacheChannelProps<RedisConnectionLike>, RedisChannelOpt {
+    /**
+     * Redis client
+     *
+     * @type {RedisClientType}
+     * */
+    client: RedisClientType;
+}
+/**
+ * Redis direct channel options
+ * */
+export interface RedisDirectChannelOpt extends RedisChannelOpt {
+    /**
+     * Name for logger
+     *
+     * @type {string}
+     * */
+    name?: string;
+}

package/dist/channel/index.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/channel/redis-direct.channel.d.ts

@@ -0,0 +1,17 @@
+import { RedisChannel } from "./redis.channel";
+import { type Entity } from "@samet-it/be-base-common";
+import type { RedisConnectionLike } from "../connection";
+import type { RedisDirectChannelOpt } from "./index.types";
+import type { KeyValue } from "@leyyo/common";
+/**
+ * Redis direct channel class
+ * */
+export declare class RedisDirectChannel<ID extends KeyValue, ENTITY extends Entity<ID>> extends RedisChannel<ID, ENTITY> {
+    /**
+     * Constructor
+     *
+     * @param {RedisConnectionLike} conn - connection
+     * @param {RedisDirectChannelOpt?} opt - direct options
+     * */
+    constructor(conn: RedisConnectionLike, opt?: RedisDirectChannelOpt);
+}

package/dist/channel/redis-direct.channel.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisDirectChannel = void 0;
+const redis_channel_1 = require("./redis.channel");
+const be_base_common_1 = require("@samet-it/be-base-common");
+/**
+ * Redis direct channel class
+ * */
+class RedisDirectChannel extends redis_channel_1.RedisChannel {
+    /**
+     * Constructor
+     *
+     * @param {RedisConnectionLike} conn - connection
+     * @param {RedisDirectChannelOpt?} opt - direct options
+     * */
+    constructor(conn, opt) {
+        super(conn, opt);
+        this.logger = be_base_common_1.logger.of(`RedisDirect${opt.name ? '#' + opt.name : ''}`);
+    }
+}
+exports.RedisDirectChannel = RedisDirectChannel;

package/dist/channel/redis.channel.d.ts

@@ -0,0 +1,28 @@
+import type { RedisConnectionLike } from "../connection";
+import type { RedisChannelProps, RedisChannelLike, RedisChannelOpt } from "./index.types";
+import { type Entity } from "@samet-it/be-base-common";
+import { CacheChannel } from "@samet-it/be-cache-common";
+import type { KeyValue, Opt } from "@leyyo/common";
+/**
+ * Redis abstract channel class
+ * */
+export declare abstract class RedisChannel<ID extends KeyValue, ENTITY extends Entity<ID>> extends CacheChannel<RedisConnectionLike, ID, ENTITY> implements RedisChannelLike<ID, ENTITY> {
+    /** @inheritDoc */
+    protected _props: RedisChannelProps;
+    protected constructor(conn: RedisConnectionLike, opt?: RedisChannelOpt);
+    protected _checkError(e: Error, opt?: Opt): void;
+    /** @inheritDoc */
+    get props(): Readonly<RedisChannelProps>;
+    /** @inheritDoc */
+    $get(...paths: Array<string>): Promise<Array<string>>;
+    /** @inheritDoc */
+    $set(map: Record<string, string>): Promise<number>;
+    /** @inheritDoc */
+    $delete(...paths: string[]): Promise<number>;
+    /** @inheritDoc */
+    $addLinks(idPath: string, paths: string): Promise<number>;
+    /** @inheritDoc */
+    $expire(path: string, seconds: number): Promise<boolean>;
+    /** @inheritDoc */
+    $getLinks(idPath: string): Promise<Array<string>>;
+}

package/dist/channel/redis.channel.js

@@ -0,0 +1,179 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisChannel = void 0;
+const be_base_common_1 = require("@samet-it/be-base-common");
+const be_cache_common_1 = require("@samet-it/be-cache-common");
+// noinspection JSUnusedGlobalSymbols
+/**
+ * Redis abstract channel class
+ * */
+class RedisChannel extends be_cache_common_1.CacheChannel {
+    // endregion protected-property
+    constructor(conn, opt) {
+        super(conn, opt);
+        conn.onFirstConnected(() => __awaiter(this, void 0, void 0, function* () {
+            this._props.client = conn.props.client;
+            this._props.isConnected = true;
+        }));
+        conn.onConnected(() => __awaiter(this, void 0, void 0, function* () {
+            this._props.client = conn.props.client;
+            this._props.isConnected = true;
+        }));
+        conn.onDisconnected(() => __awaiter(this, void 0, void 0, function* () {
+            this._props.client = undefined;
+            this._props.isConnected = false;
+        }));
+    }
+    _checkError(e, opt) {
+        be_base_common_1.errorHandler.addStat(e);
+        if (e instanceof be_cache_common_1.CacheError) {
+            // todo append params
+            throw e;
+        }
+        else {
+            throw be_base_common_1.errorHandler.common.castForClass(be_cache_common_1.CacheError, e, opt);
+        }
+    }
+    // region getter
+    /** @inheritDoc */
+    get props() {
+        return this._props;
+    }
+    // endregion getter
+    // region native-calls
+    /** @inheritDoc */
+    $get(...paths) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { client } = this._props;
+            if (!client) {
+                return [];
+            }
+            if (paths.length < 1) {
+                return [];
+            }
+            if (paths.length == 1) {
+                const rec = (yield client.get(paths[0]));
+                return rec ? [rec] : [];
+            }
+            try {
+                return (yield client.mGet(paths));
+            }
+            catch (e) {
+                this._checkError(e, { redis: 'MGET' });
+            }
+        });
+    }
+    /** @inheritDoc */
+    $set(map) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { client } = this._props;
+            if (!client) {
+                return 0;
+            }
+            if (!map || typeof map !== 'object' || Array.isArray(map)) {
+                return 0;
+            }
+            const keys = Object.keys(map);
+            switch (keys.length) {
+                case 0:
+                    return 0;
+                case 1:
+                    const key = keys[0];
+                    try {
+                        yield client.set(key, map[key]);
+                    }
+                    catch (e) {
+                        this._checkError(e, { redis: 'SET' });
+                    }
+                    return 1;
+                default:
+                    try {
+                        yield client.mSet(map);
+                    }
+                    catch (e) {
+                        this._checkError(e, { redis: 'MSET' });
+                    }
+                    return keys.length;
+            }
+        });
+    }
+    /** @inheritDoc */
+    $delete(...paths) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { client } = this._props;
+            if (!client) {
+                return 0;
+            }
+            if (paths.length < 1) {
+                return 0;
+            }
+            try {
+                yield client.del(paths);
+            }
+            catch (e) {
+                this._checkError(e, { redis: 'DEL' });
+            }
+            return paths.length;
+        });
+    }
+    /** @inheritDoc */
+    $addLinks(idPath, paths) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { client } = this._props;
+            if (!client) {
+                return 0;
+            }
+            if (paths.length < 1) {
+                return 0;
+            }
+            try {
+                yield client.sAdd(idPath, paths);
+            }
+            catch (e) {
+                this._checkError(e, { redis: 'SADD' });
+            }
+            return paths.length;
+        });
+    }
+    /** @inheritDoc */
+    $expire(path, seconds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { client } = this._props;
+            if (!client) {
+                return false;
+            }
+            try {
+                return (yield client.expire(path, seconds)) > 0;
+            }
+            catch (e) {
+                this._checkError(e, { redis: 'EXPIRE' });
+            }
+        });
+    }
+    /** @inheritDoc */
+    $getLinks(idPath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const { client } = this._props;
+            if (!client) {
+                return [];
+            }
+            try {
+                return (_a = (yield client.sMembers(idPath))) !== null && _a !== void 0 ? _a : [];
+            }
+            catch (e) {
+                this._checkError(e, { redis: 'SMEMBERS' });
+            }
+        });
+    }
+}
+exports.RedisChannel = RedisChannel;

package/dist/config/index.d.ts

@@ -0,0 +1,2 @@
+export * from './redis-common.config';
+export * from './index.types';

package/dist/config/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./redis-common.config"), exports);
+__exportStar(require("./index.types"), exports);

package/dist/config/index.types.d.ts

@@ -0,0 +1,31 @@
+import type { EnvBase } from "@leyyo/env";
+export interface RedisCommonConf extends EnvBase {
+    /**
+     * Redis Protocol
+     * */
+    readonly PROTOCOL: string;
+    /**
+     * Redis Host
+     * */
+    readonly HOST: string;
+    /**
+     * Redis Port
+     * */
+    readonly PORT: number;
+    /**
+     * DB User
+     * */
+    readonly USER: string;
+    /**
+     * DB Password
+     * */
+    readonly PASS: string;
+    /**
+     * Redis prefix for keys
+     * */
+    readonly PREFIX: string;
+    /**
+     * Redis DB number
+     * */
+    readonly DB_NUMBER: number;
+}

package/dist/config/index.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/config/redis-common.config.d.ts

@@ -0,0 +1,5 @@
+import type { RedisCommonConf } from "./index.types";
+/**
+ * Redis common config
+ * */
+export declare const redisCommonConfig: import("@leyyo/env").EnvScopeRuntime<RedisCommonConf, "REDIS", undefined>;

package/dist/config/redis-common.config.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.redisCommonConfig = void 0;
+const env_1 = require("@leyyo/env");
+/**
+ * Redis common config
+ * */
+exports.redisCommonConfig = env_1.envCore.configure
+    .scope('RedisCommon', 'REDIS')
+    .start()
+    .field('PROTOCOL').text().def('redis').end()
+    .field('HOST').text().required().end()
+    .field('PORT').integer().def(6379).end()
+    .field('USER').text().end()
+    .field('PASS').text().end()
+    .field('PREFIX').text().end()
+    .field('DB_NUMBER').integer().end()
+    .finish();

package/dist/connection/index.d.ts

@@ -0,0 +1,4 @@
+export * from './index.types';
+export * from './redis.connection';
+export * from './redis-direct.connection';
+export * from './redis-connection.fn';

package/dist/connection/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./index.types"), exports);
+__exportStar(require("./redis.connection"), exports);
+__exportStar(require("./redis-direct.connection"), exports);
+__exportStar(require("./redis-connection.fn"), exports);

package/dist/connection/index.types.d.ts

@@ -0,0 +1,74 @@
+import type { CacheConnectionLike, CacheConnOpt, CacheExecOpt } from "@samet-it/be-cache-common";
+import type { RedisClientType } from "redis";
+import type { Entity } from "@samet-it/be-base-common";
+import type { RedisDirectChannelOpt, RedisChannelLike } from "../channel";
+import type { CacheConnProps } from "@samet-it/be-cache-common";
+import { KeyValue } from "@leyyo/common";
+/**
+ * Redis connection interface
+ * */
+export interface RedisConnectionLike extends CacheConnectionLike<RedisExecOpt> {
+    /** @inheritDoc */
+    get props(): Readonly<RedisConnProps>;
+}
+/**
+ * Redis direct connection interface
+ * */
+export interface RedisDirectConnectionLike extends RedisConnectionLike {
+    /**
+     * Create new channel
+     *
+     * @param {RedisDirectChannelOpt?} opt - direct channel options
+     * @return {RedisChannelLike<Entity>} - new channel
+     * */
+    newChannel<ID extends KeyValue, ENTITY extends Entity<ID>>(opt?: RedisDirectChannelOpt): RedisChannelLike<ID, ENTITY>;
+}
+/**
+ * Redis connection option
+ * */
+export interface RedisConnOpt extends CacheConnOpt {
+    /**
+     * Redis DB number
+     *
+     * @type {number}
+     * */
+    dbNumber?: number;
+}
+/**
+ * Redis direct connection option
+ * */
+export interface RedisConnDirectOpt extends RedisConnOpt {
+    /**
+     * logger name
+     *
+     * @type {string}
+     * */
+    name?: string;
+}
+/**
+ * Redis connection props
+ * */
+export interface RedisConnProps extends CacheConnProps, RedisConnOpt {
+    /**
+     * Redis client
+     *
+     * @type {RedisClientType}
+     * */
+    client: RedisClientType;
+    /**
+     * Connection try count
+     *
+     * @type {number}
+     * */
+    tryCount: number;
+    /**
+     * Connection url
+     *
+     * @type {string}
+     * */
+    producedUrl: string;
+}
+/**
+ * Redis query option
+ * */
+export type RedisExecOpt = CacheExecOpt;

package/dist/connection/index.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/connection/redis-connection.fn.d.ts

@@ -0,0 +1,8 @@
+import type { RedisConnDirectOpt, RedisDirectConnectionLike } from "./index.types";
+/**
+ * Crete new redis connection
+ *
+ * @param {RedisConnDirectOpt} opt - option
+ * @return {RedisDirectConnectionLike} - new redis connection
+ * */
+export declare function redisConnection(opt?: RedisConnDirectOpt): RedisDirectConnectionLike;

package/dist/connection/redis-connection.fn.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.redisConnection = redisConnection;
+const redis_direct_connection_1 = require("./redis-direct.connection");
+// noinspection JSUnusedGlobalSymbols
+/**
+ * Crete new redis connection
+ *
+ * @param {RedisConnDirectOpt} opt - option
+ * @return {RedisDirectConnectionLike} - new redis connection
+ * */
+function redisConnection(opt) {
+    return new redis_direct_connection_1.RedisDirectConnection(opt);
+}

package/dist/connection/redis-direct.connection.d.ts

@@ -0,0 +1,18 @@
+import { RedisConnection } from "./redis.connection";
+import { type Entity } from "@samet-it/be-base-common";
+import { type RedisDirectChannelOpt, type RedisChannelLike } from "../channel";
+import type { RedisConnDirectOpt, RedisDirectConnectionLike } from "./index.types";
+import type { KeyValue } from "@leyyo/common";
+/**
+ * Redis connection direct class
+ * */
+export declare class RedisDirectConnection extends RedisConnection implements RedisDirectConnectionLike {
+    /**
+     * Constructor
+     *
+     * @param {RedisConnDirectOpt} opt - options
+     * */
+    constructor(opt?: RedisConnDirectOpt);
+    /** @inheritDoc */
+    newChannel<ID extends KeyValue, ENTITY extends Entity<ID>>(opt?: RedisDirectChannelOpt): RedisChannelLike<ID, ENTITY>;
+}

package/dist/connection/redis-direct.connection.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisDirectConnection = void 0;
+const redis_connection_1 = require("./redis.connection");
+const be_base_common_1 = require("@samet-it/be-base-common");
+const channel_1 = require("../channel");
+/**
+ * Redis connection direct class
+ * */
+class RedisDirectConnection extends redis_connection_1.RedisConnection {
+    /**
+     * Constructor
+     *
+     * @param {RedisConnDirectOpt} opt - options
+     * */
+    constructor(opt) {
+        super(opt);
+        this.logger = be_base_common_1.logger.of(`RedisConnection${(opt === null || opt === void 0 ? void 0 : opt.name) ? '#' + (opt === null || opt === void 0 ? void 0 : opt.name) : ''}`);
+    }
+    /** @inheritDoc */
+    newChannel(opt) {
+        return new channel_1.RedisDirectChannel(this, opt);
+    }
+}
+exports.RedisDirectConnection = RedisDirectConnection;

package/dist/connection/redis.connection.d.ts

@@ -0,0 +1,48 @@
+import type { RedisConnectionLike, RedisExecOpt, RedisConnProps, RedisConnOpt } from "./index.types";
+import { CacheConnection } from "@samet-it/be-cache-common";
+/**
+ * Redis connection abstract class
+ * */
+export declare abstract class RedisConnection extends CacheConnection<RedisExecOpt> implements RedisConnectionLike {
+    /**
+     * Base/starting/min delay
+     *
+     * @type {number} - as seconds
+     * */
+    private static readonly BASE_DELAY;
+    /**
+     * Last/max delay
+     *
+     * @type {number} - as seconds
+     * */
+    private static readonly MAX_DELAY;
+    /**
+     * Try count
+     *
+     * @type {number} - times
+     * */
+    private static readonly TRY_COUNT;
+    /** {@inheritDoc} */
+    protected _props: RedisConnProps;
+    protected constructor(opt?: RedisConnOpt);
+    /** @inheritDoc */
+    get props(): Readonly<RedisConnProps>;
+    /**
+     * Read credentials from environment
+     * */
+    protected _readFromEnv(): void;
+    /**
+     * Build url from credentials
+     * */
+    protected _buildUrl(): void;
+    /**
+     * Generate next delay time with exponential & randomized manner
+     *
+     * @return {number}
+     * */
+    protected _delayWithJitter(): number;
+    /** {@inheritDoc} */
+    connect(): Promise<boolean>;
+    /** {@inheritDoc} */
+    ping(next?: boolean): Promise<boolean>;
+}

package/dist/connection/redis.connection.js

@@ -0,0 +1,205 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisConnection = void 0;
+const redis = __importStar(require("redis"));
+const config_1 = require("../config");
+const be_cache_common_1 = require("@samet-it/be-cache-common");
+/**
+ * Redis connection abstract class
+ * */
+class RedisConnection extends be_cache_common_1.CacheConnection {
+    // endregion protected-property
+    constructor(opt) {
+        super(opt);
+        this._props.tryCount = 0;
+        this._readFromEnv();
+        this._buildUrl();
+    }
+    // region getter
+    /** @inheritDoc */
+    get props() {
+        return this._props;
+    }
+    // endregion getter
+    // region protected-method
+    /**
+     * Read credentials from environment
+     * */
+    _readFromEnv() {
+        var _a, _b, _c, _d, _e, _f;
+        const { _props: props } = this;
+        let env = config_1.redisCommonConfig.valueShort;
+        if (props.envVariant) {
+            env = config_1.redisCommonConfig.configure.getVariation(props.envVariant).valueShort;
+        }
+        this._props.protocol = (_a = this._props.protocol) !== null && _a !== void 0 ? _a : env.PROTOCOL;
+        this._props.host = (_b = this._props.host) !== null && _b !== void 0 ? _b : env.HOST;
+        this._props.port = (_c = this._props.port) !== null && _c !== void 0 ? _c : env.PORT;
+        this._props.username = (_d = this._props.username) !== null && _d !== void 0 ? _d : env.USER;
+        this._props.password = (_e = this._props.password) !== null && _e !== void 0 ? _e : env.PASS;
+        this._props.dbNumber = (_f = this._props.dbNumber) !== null && _f !== void 0 ? _f : env.DB_NUMBER;
+    }
+    /**
+     * Build url from credentials
+     * */
+    _buildUrl() {
+        const { username, password, dbNumber, port, host, protocol } = this._props;
+        let _secure = '';
+        if (username) {
+            _secure = username;
+            if (password) {
+                _secure += ':' + password;
+            }
+            _secure += '@';
+        }
+        let _db = '';
+        if (dbNumber !== undefined) {
+            _db = '/' + dbNumber;
+        }
+        let _port = '';
+        if (port !== undefined) {
+            _port = ':' + port;
+        }
+        this._props.producedUrl = `${protocol}://${_secure}${host}${_port}${_db}`;
+    }
+    /**
+     * Generate next delay time with exponential & randomized manner
+     *
+     * @return {number}
+     * */
+    _delayWithJitter() {
+        const exp = Math.min(RedisConnection.BASE_DELAY * Math.pow(2, this._props.tryCount), RedisConnection.MAX_DELAY);
+        return exp / 2 + Math.random() * (exp / 2);
+    }
+    // endregion protected-method
+    // region connect
+    /** {@inheritDoc} */
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._props.isConnected) {
+                return true;
+            }
+            if (this._props.tryCount > RedisConnection.TRY_COUNT) {
+                this.logger.error(`on[error/*], maximum try`);
+                return false;
+            }
+            try {
+                this._props.client = redis.createClient({ url: this._props.producedUrl });
+                this._props.client
+                    .on("error", err => {
+                    this.checkError(err, { silent: true, name: 'connection' });
+                    this._props.tryCount++;
+                    const old = this._props.isConnected;
+                    this._props.isConnected = false;
+                    if (old) {
+                        this._triggerOnCase('disconnected', this._onDisconnected, false);
+                    }
+                    setTimeout(() => this.connect().then(), this._delayWithJitter());
+                })
+                    .on('connect', () => {
+                    this.logger.info(`on[connect]`);
+                    this._props.isConnected = true;
+                    this._props.tryCount = 0;
+                    this._triggerOnCase('connected', this._onConnected, false);
+                    if (this._props.isFirst === undefined) {
+                        this._triggerOnCase('first-connected', this._onFirstConnected, true);
+                        this._props.isFirst = false;
+                    }
+                })
+                    .on('ready', () => this.logger.info('on[ready]'))
+                    .on('close', () => this.logger.info('on[close]'))
+                    .on('reconnecting', () => this.logger.info('on[reconnecting]'))
+                    .on('end', () => this.logger.info('on[end]'));
+                yield this._props.client.connect();
+                this.logger.log('Connected');
+                setTimeout(() => this.ping(true).then(), 30000);
+            }
+            catch (e) {
+                this.checkError(e, { name: 'connection' });
+            }
+            return true;
+        });
+    }
+    /** {@inheritDoc} */
+    ping(next) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // this._props.client.destroy()
+            let result = false;
+            if (this._props.isConnected) {
+                try {
+                    yield this._props.client.ping();
+                    result = true;
+                }
+                catch (err) {
+                    this.checkError(err, { silent: true, name: 'ping' });
+                }
+            }
+            if (next) {
+                setTimeout(() => this.ping(true).then(), 30000);
+            }
+            return result;
+        });
+    }
+}
+exports.RedisConnection = RedisConnection;
+// region private-property
+/**
+ * Base/starting/min delay
+ *
+ * @type {number} - as seconds
+ * */
+RedisConnection.BASE_DELAY = 500; // 0.5 sec
+/**
+ * Last/max delay
+ *
+ * @type {number} - as seconds
+ * */
+RedisConnection.MAX_DELAY = 1000 * 60 * 60; // 1 hour
+/**
+ * Try count
+ *
+ * @type {number} - times
+ * */
+RedisConnection.TRY_COUNT = 100; // 100 times

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './connection';
+export * from './config';
+export * from './channel';

package/dist/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./connection"), exports);
+__exportStar(require("./config"), exports);
+__exportStar(require("./channel"), exports);

package/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "@samet-it/be-redis-common",
+  "version": "1.1.1",
+  "description": "Redis common component",
+  "keywords": [
+    "redis",
+    "cache"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/samet-digital/be-redis-common.git"
+  },
+  "bugs": {
+    "email": "mustafay@samet.com.tr",
+    "url": "https://https://github.com/samet-digital/be-redis-common/issues"
+  },
+  "homepage": "https://https://github.com/samet-digital/be-redis-common#readme",
+  "author": {
+    "name": "Mustafa Yelmer",
+    "email": "mustafay@samet.com.tr"
+  },
+  "main": "dist/index.js",
+  "type": "commonjs",
+  "scripts": {
+    "clear": "rimraf dist && rimraf coverage",
+    "clear:nm": "rimraf node_modules && npm run clear",
+    "lint": "eslint src/**/*.ts --quiet",
+    "lint:verbose": "eslint src/**/*.ts",
+    "asset": "node -r ts-node/register commands/assets.ts",
+    "build": "npm run clear && tsc && npm run asset",
+    "test": "jest --config=jest.json --detectOpenHandles",
+    "coverage": "rimraf coverage && jest --config=jest.json --coverage --coverageDirectory=coverage",
+    "sample": "node -r ts-node/register src/sample.ts",
+    "publish:public": "npm run build && npm publish -access=public"
+  },
+  "files": [
+    "dist/*"
+  ],
+  "license": "ISC",
+  "devDependencies": {
+    "@babel/preset-env": "^7.28.0",
+    "@babel/preset-typescript": "^7.27.1",
+    "@eslint/js": "^9.33.0",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^24.2.1",
+    "@typescript-eslint/eslint-plugin": "^8.39.1",
+    "@typescript-eslint/parser": "^8.39.1",
+    "eslint": "^9.33.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-config-standard": "^17.1.0",
+    "eslint-plugin-import": "^2.32.0",
+    "eslint-plugin-jsdoc": "^54.0.0",
+    "eslint-plugin-node": "^11.1.0",
+    "husky": "^9.1.7",
+    "jest": "^29.7.0",
+    "prettier": "^3.6.2",
+    "rimraf": "^6.0.1",
+    "test": "^3.3.0",
+    "ts-jest": "^29.4.1",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.2",
+    "typescript-eslint": "^8.39.1"
+  },
+  "overrides": {
+    "eslint-config-standard": {
+      "eslint": "^9.33.0"
+    }
+  },
+  "dependencies": {
+    "@leyyo/common": "^1.2.1",
+    "@leyyo/env": "^1.2.1",
+    "@samet-it/be-base-common": "^1.1.1",
+    "@samet-it/be-cache-common": "^1.1.1",
+    "redis": "^5.10.0"
+  }
+}