@powfix/core-js 0.9.22

package/dist/src/utils/UuidUtils.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UuidUtils = void 0;
+const uuid = require('uuid');
+function binaryToString(binary) {
+    return Buffer.from(binary).toString('hex');
+}
+class UuidUtils {
+    static v4() {
+        return uuid.v4();
+    }
+    static format(uuid) {
+        if (uuid.length === 32) {
+            // Without dash: ca23c587d7f84c76be59f53bbc9f91f8
+            return `${uuid.substring(0, 8)}-${uuid.substring(8, 12)}-${uuid.substring(12, 16)}-${uuid.substring(16, 20)}-${uuid.substring(20, 32)}`.toUpperCase();
+        }
+        else if (uuid.length === 36) {
+            // With dash: ca23c587-d7f8-4c76-be59-f53bbc9f91f8
+            return uuid.toUpperCase();
+        }
+        else {
+            // Unexpected uuid
+            console.warn('Unexpected uuid length', uuid);
+            return uuid;
+        }
+    }
+    /**
+     * (UUID: Buffer) to (UUID: string)
+     * @param binary UUID
+     * @returns {string|null} When binary not exists return null
+     */
+    static toString(binary) {
+        if (!binary)
+            return null;
+        return UuidUtils.format(binaryToString(binary));
+    }
+    /** (UUID: string) to (UUID: Buffer) */
+    static toBuffer(uuid) {
+        return Buffer.from(uuid.replace(/-/g, ''), 'hex');
+    }
+    static isValidUUID(uuid) {
+        if (!uuid)
+            return false;
+        if (typeof uuid !== 'string')
+            return false;
+        return RegExp(/^[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}$/i).test(uuid);
+    }
+}
+exports.UuidUtils = UuidUtils;

package/dist/src/utils/Validator.d.ts

@@ -0,0 +1,48 @@
+export declare class Validator {
+    static validate(value: string | null | undefined, options: Validator.Options): {
+        result: boolean;
+        validations: Validator.VALIDATION[];
+        passes: Validator.VALIDATION[];
+        errors: Validator.VALIDATION[];
+    };
+}
+export declare namespace Validator {
+    enum VALIDATION {
+        MIN_LENGTH = "MIN_LENGTH",
+        MAX_LENGTH = "MAX_LENGTH",
+        SPACE_MIN_COUNT = "SPACE_MIN_COUNT",
+        SPACE_MAX_COUNT = "SPACE_MAX_COUNT",
+        NUMBER_MIN_COUNT = "NUMBER_MIN_COUNT",
+        NUMBER_MAX_COUNT = "NUMBER_MAX_COUNT",
+        ALPHABET_MIN_COUNT = "ALPHABET_MIN_COUNT",
+        ALPHABET_MAX_COUNT = "ALPHABET_MAX_COUNT",
+        ALPHABET_LOWER_CASE_MIN_COUNT = "ALPHABET_LOWER_CASE_MIN_COUNT",
+        ALPHABET_LOWER_CASE_MAX_COUNT = "ALPHABET_LOWER_CASE_MAX_COUNT",
+        ALPHABET_UPPER_CASE_MIN_COUNT = "ALPHABET_UPPER_CASE_MIN_COUNT",
+        ALPHABET_UPPER_CASE_MAX_COUNT = "ALPHABET_UPPER_CASE_MAX_COUNT",
+        SPECIAL_CHARACTER_MIN_COUNT = "SPECIAL_CHARACTER_MIN_COUNT",
+        SPECIAL_CHARACTER_MAX_COUNT = "SPECIAL_CHARACTER_MAX_COUNT",
+        STARTS_WITH_ALPHABET = "STARTS_WITH_ALPHABET",
+        STARTS_WITH_NUMBER = "STARTS_WITH_NUMBER",
+        STARTS_WITH_SPECIAL_CHARACTER = "STARTS_WITH_SPECIAL_CHARACTER"
+    }
+    interface Options {
+        minLength?: number;
+        maxLength?: number;
+        spaceMinCount?: number;
+        spaceMaxCount?: number;
+        numberMinCount?: number;
+        numberMaxCount?: number;
+        alphabetMinCount?: number;
+        alphabetMaxCount?: number;
+        alphabetLowerCaseMinCount?: number;
+        alphabetLowerCaseMaxCount?: number;
+        alphabetUpperCaseMinCount?: number;
+        alphabetUpperCaseMaxCount?: number;
+        specialCharacterMinCount?: number;
+        specialCharacterMaxCount?: number;
+        startsWithNumber?: boolean;
+        startsWithAlphabet?: boolean;
+        startsWithSpecialCharacter?: boolean;
+    }
+}

package/dist/src/utils/Validator.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Validator = void 0;
+class Validator {
+    static validate(value, options) {
+        value = value || '';
+        const validations = [];
+        const errors = [];
+        const { length } = value;
+        const spaceCount = (value.match(/\s/g) || []).length;
+        const numberCount = (value.match(/\d/g) || []).length;
+        const alphabetCount = (value.match(/[A-Za-z]/g) || []).length;
+        const alphabetLowerCaseCount = (value.match(/[a-z]/g) || []).length;
+        const alphabetUpperCaseCount = (value.match(/[A-Z]/g) || []).length;
+        const specialCount = (value.match(/[~`!@#$%^&*()\-+={[}\]|\\:;"'<,>.?/]/g) || []).length;
+        const startsWithNumber = /^\d/.test(value);
+        const startsWithAlphabet = /^[A-Za-z]/.test(value);
+        const startsWithSpecialCharacter = /^[~`!@#$%^&*()\-+={[}\]|\\:;"'<,>.?/]/.test(value);
+        // 최소 길이
+        if (options.minLength !== undefined && options.minLength > -1) {
+            validations.push(Validator.VALIDATION.MIN_LENGTH);
+            if (length < options.minLength) {
+                errors.push(Validator.VALIDATION.MIN_LENGTH);
+            }
+        }
+        // 최대 길이
+        if (options.maxLength !== undefined && options.maxLength > -1) {
+            validations.push(Validator.VALIDATION.MAX_LENGTH);
+            if (length > options.maxLength) {
+                errors.push(Validator.VALIDATION.MAX_LENGTH);
+            }
+        }
+        const validateMin = (option, value, validation) => {
+            if (option !== undefined && option > -1) {
+                validations.push(validation);
+                if (value < option) {
+                    errors.push(validation);
+                }
+            }
+        };
+        const validateMax = (option, value, validation) => {
+            if (option !== undefined && option > -1) {
+                validations.push(validation);
+                if (value > option) {
+                    errors.push(validation);
+                }
+            }
+        };
+        // 공백 개수
+        validateMin(options.spaceMinCount, spaceCount, Validator.VALIDATION.SPACE_MIN_COUNT);
+        validateMax(options.spaceMaxCount, spaceCount, Validator.VALIDATION.SPACE_MAX_COUNT);
+        // 숫자 개수
+        validateMin(options.numberMinCount, numberCount, Validator.VALIDATION.NUMBER_MIN_COUNT);
+        validateMax(options.numberMaxCount, numberCount, Validator.VALIDATION.NUMBER_MAX_COUNT);
+        // 알파벳 개수
+        validateMin(options.alphabetMinCount, alphabetCount, Validator.VALIDATION.ALPHABET_MIN_COUNT);
+        validateMax(options.alphabetMaxCount, alphabetCount, Validator.VALIDATION.ALPHABET_MAX_COUNT);
+        // 알파벳(소문자) 개수
+        validateMin(options.alphabetLowerCaseMinCount, alphabetLowerCaseCount, Validator.VALIDATION.ALPHABET_LOWER_CASE_MIN_COUNT);
+        validateMax(options.alphabetLowerCaseMaxCount, alphabetLowerCaseCount, Validator.VALIDATION.ALPHABET_LOWER_CASE_MAX_COUNT);
+        // 알파벳(대문자) 개수
+        validateMin(options.alphabetUpperCaseMinCount, alphabetUpperCaseCount, Validator.VALIDATION.ALPHABET_UPPER_CASE_MIN_COUNT);
+        validateMax(options.alphabetUpperCaseMaxCount, alphabetUpperCaseCount, Validator.VALIDATION.ALPHABET_UPPER_CASE_MAX_COUNT);
+        // 특수문자 개수
+        validateMin(options.specialCharacterMinCount, specialCount, Validator.VALIDATION.SPECIAL_CHARACTER_MIN_COUNT);
+        validateMax(options.specialCharacterMaxCount, specialCount, Validator.VALIDATION.SPECIAL_CHARACTER_MAX_COUNT);
+        // 숫자로 시작
+        if (options.startsWithNumber) {
+            validations.push(Validator.VALIDATION.STARTS_WITH_NUMBER);
+            if (!startsWithNumber) {
+                errors.push(Validator.VALIDATION.STARTS_WITH_NUMBER);
+            }
+        }
+        // 영문으로 시작
+        if (options.startsWithAlphabet) {
+            validations.push(Validator.VALIDATION.STARTS_WITH_ALPHABET);
+            if (!startsWithAlphabet) {
+                errors.push(Validator.VALIDATION.STARTS_WITH_ALPHABET);
+            }
+        }
+        // 특수문자로 시작
+        if (options.startsWithSpecialCharacter) {
+            validations.push(Validator.VALIDATION.STARTS_WITH_SPECIAL_CHARACTER);
+            if (!startsWithSpecialCharacter) {
+                errors.push(Validator.VALIDATION.STARTS_WITH_SPECIAL_CHARACTER);
+            }
+        }
+        return {
+            result: errors.length === 0,
+            validations,
+            passes: validations.filter(e => !errors.includes(e)),
+            errors,
+        };
+    }
+}
+exports.Validator = Validator;
+(function (Validator) {
+    let VALIDATION;
+    (function (VALIDATION) {
+        VALIDATION["MIN_LENGTH"] = "MIN_LENGTH";
+        VALIDATION["MAX_LENGTH"] = "MAX_LENGTH";
+        VALIDATION["SPACE_MIN_COUNT"] = "SPACE_MIN_COUNT";
+        VALIDATION["SPACE_MAX_COUNT"] = "SPACE_MAX_COUNT";
+        VALIDATION["NUMBER_MIN_COUNT"] = "NUMBER_MIN_COUNT";
+        VALIDATION["NUMBER_MAX_COUNT"] = "NUMBER_MAX_COUNT";
+        VALIDATION["ALPHABET_MIN_COUNT"] = "ALPHABET_MIN_COUNT";
+        VALIDATION["ALPHABET_MAX_COUNT"] = "ALPHABET_MAX_COUNT";
+        VALIDATION["ALPHABET_LOWER_CASE_MIN_COUNT"] = "ALPHABET_LOWER_CASE_MIN_COUNT";
+        VALIDATION["ALPHABET_LOWER_CASE_MAX_COUNT"] = "ALPHABET_LOWER_CASE_MAX_COUNT";
+        VALIDATION["ALPHABET_UPPER_CASE_MIN_COUNT"] = "ALPHABET_UPPER_CASE_MIN_COUNT";
+        VALIDATION["ALPHABET_UPPER_CASE_MAX_COUNT"] = "ALPHABET_UPPER_CASE_MAX_COUNT";
+        VALIDATION["SPECIAL_CHARACTER_MIN_COUNT"] = "SPECIAL_CHARACTER_MIN_COUNT";
+        VALIDATION["SPECIAL_CHARACTER_MAX_COUNT"] = "SPECIAL_CHARACTER_MAX_COUNT";
+        VALIDATION["STARTS_WITH_ALPHABET"] = "STARTS_WITH_ALPHABET";
+        VALIDATION["STARTS_WITH_NUMBER"] = "STARTS_WITH_NUMBER";
+        VALIDATION["STARTS_WITH_SPECIAL_CHARACTER"] = "STARTS_WITH_SPECIAL_CHARACTER";
+    })(VALIDATION = Validator.VALIDATION || (Validator.VALIDATION = {}));
+})(Validator || (exports.Validator = Validator = {}));

package/dist/src/utils/global/between.d.ts

@@ -0,0 +1 @@
+export declare const between: (value: number, from: number, to: number) => boolean;

package/dist/src/utils/global/between.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.between = void 0;
+const between = (value, from, to) => {
+    return value >= from && value <= to;
+};
+exports.between = between;

package/dist/src/utils/global/sleep.d.ts

@@ -0,0 +1 @@
+export declare const sleep: (delayInMilliseconds: number, callback?: ((...args: any) => void) | undefined, ...args: any) => Promise<any[]>;

package/dist/src/utils/global/sleep.js

@@ -0,0 +1,21 @@
+"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.sleep = void 0;
+const sleep = (delayInMilliseconds, callback, ...args) => __awaiter(void 0, void 0, void 0, function* () {
+    return new Promise((resolve) => {
+        setTimeout(() => {
+            callback === null || callback === void 0 ? void 0 : callback(...args);
+            resolve(args);
+        }, delayInMilliseconds);
+    });
+});
+exports.sleep = sleep;

package/index.ts

@@ -0,0 +1,5 @@
+// Extend browser imports & exports
+export * from './browser';
+
+// services
+export * from './src/services';

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@powfix/core-js",
+  "version": "0.9.22",
+  "description": "core package",
+  "author": "Kwon Kyung-Min <powfix@gmail.com>",
+  "private": false,
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/powfix/core-js"
+  },
+  "keywords": [
+    "javascript",
+    "core",
+    "util"
+  ],
+  "homepage": "https://github.com/powfix/core-js",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "browser": "dist/browser.js",
+  "scripts": {
+    "clean": "rm -rf dist",
+    "build": "yarn clean && tsc -p . && git add dist"
+  },
+  "dependencies": {
+    "base-64": "^1.0.0",
+    "jwt-decode": "^4.0.0",
+    "redis": "^4.6.11",
+    "uuid": "9.0.1"
+  },
+  "devDependencies": {
+    "@types/base-64": "1.0.2",
+    "@types/node": "20.9.5",
+    "@types/uuid": "9.0.7",
+    "axios": "^1.7.2",
+    "moment": "^2.30.1",
+    "typescript": "5.1.6"
+  },
+  "peerDependencies": {
+    "axios": ">=1.7.0",
+    "moment": ">=2.0.0"
+  }
+}

package/src/constants/COORDINATE.ts

@@ -0,0 +1,9 @@
+export class COORDINATE {
+  public static LATITUDE_MIN_LENGTH = 1;
+  public static LATITUDE_MAX_LENGTH = 10;
+
+  public static LONGITUDE_MIN_LENGTH = 1;
+  public static LONGITUDE_MAX_LENGTH = 11;
+}
+
+export namespace COORDINATE {}

package/src/constants/DISTANCE.ts

@@ -0,0 +1,15 @@
+export class DISTANCE {
+
+}
+
+export namespace DISTANCE {
+  export enum UNIT {
+    FEET = 'FEET',
+    KILOMETERS = 'KILOMETERS',
+    MILLIMETERS = 'MILLIMETERS',
+    CENTIMETERS = 'CENTIMETERS',
+    METERS = 'METERS',
+    MILES = 'MILES',
+    YARDS = 'YARDS',
+  }
+}

package/src/constants/DURATION.ts

@@ -0,0 +1,18 @@
+export class DURATION {
+
+}
+
+export namespace DURATION {
+  export enum UNIT {
+    NANOSECONDS = 'NANOSECONDS',
+    MICROSECONDS = 'MICROSECONDS',
+    MILLISECONDS = 'MILLISECONDS',
+    SECONDS = 'SECONDS',
+    MINUTES = 'MINUTES',
+    HOURS = 'HOURS',
+    DAYS = 'DAYS',
+    YEARS = 'YEARS',
+    DECADES = 'DECADES',
+    CENTURIES = 'CENTURIES',
+  }
+}

package/src/interfaces/Coordinate.ts

@@ -0,0 +1,9 @@
+export interface Coordinate {
+  latitude: number;
+  longitude: number;
+}
+
+export interface CoordinateM {
+  lat: number;
+  lon: number;
+}

package/src/interfaces/Point2.ts

@@ -0,0 +1,4 @@
+export interface Point2 {
+  x: number;
+  y: number;
+}

package/src/interfaces/Point3.ts

@@ -0,0 +1,5 @@
+import {Point2} from "./Point2";
+
+export interface Point3 extends Point2 {
+  z: number;
+}

package/src/scripts/base64-polyfill.ts

@@ -0,0 +1,13 @@
+import {decode, encode} from 'base-64';
+
+export const base64Polyfill = () => {
+  if (!global.btoa) {
+    global.btoa = encode;
+  }
+
+  if (!global.atob) {
+    global.atob = decode;
+  }
+
+  console.log('base64-polyfill initialized', Date.now());
+};

package/src/services/Session.ts

@@ -0,0 +1,141 @@
+import {jwtDecode, JwtPayload} from "jwt-decode";
+import {AxiosInstance} from "axios";
+import moment from "moment";
+
+export interface SessionOptions {
+  api: AxiosInstance;
+  storageProvider: StorageProvider;
+}
+
+export interface StorageProvider {
+  key?: () => string;
+  set: (key: string, value: string) => Promise<void> | void;
+  get: (key: string) => Promise<string | null> | (string | null);
+  remove: (key: string) => Promise<void> | void;
+  clear?: () => Promise<void> | void;
+}
+
+const logWithTs = (...p: any) => {
+  console.log(Date.now(), ...p);
+}
+
+export class Session {
+  // Service parameters
+  protected api: AxiosInstance;
+  protected storageProvider: StorageProvider;
+
+  // Emitter
+  // private emitter = new EventEmitter({});
+  // public on = this.emitter.on;
+  // public off = this.emitter.off;
+  // private emit = this.emitter.emit;
+
+  public constructor(options: SessionOptions) {
+    // Init service parameters
+    console.log('Session initialized', Date.now(), options.api);
+    this.api = options.api;
+    this.storageProvider = options.storageProvider;
+  }
+
+  private getKey(): string {
+    try {
+      if (this.storageProvider.key) {
+        return this.storageProvider.key();
+      }
+    } catch (e) {
+      console.error(e);
+    }
+
+    return Session.STORAGE_KEY.SESSION_AUTHORIZATION;
+  }
+
+  public async hasAuthorization(): Promise<boolean> {
+    return !!(await this.getAuthorization());
+  }
+
+  public async getAuthorization(): Promise<string | null> {
+    return this.storageProvider.get(this.getKey());
+  }
+
+  public async setAuthorization(authorization?: string | null): Promise<string | null> {
+    if (authorization === null) {
+      await this.removeAuthorization();
+      return null;
+    }
+
+    let nextAuthorization = await (async () => {
+      if (authorization === undefined) {
+        return await this.getAuthorization();
+      }
+      return authorization;
+    })();
+
+    if (!nextAuthorization) {
+      console.log('nextAuthorization is null or undefined');
+      return null;
+    }
+
+    try {
+      // Replace Bearer prefix
+      nextAuthorization = nextAuthorization.replace(/^Bearer\s+/, '');
+
+      const decoded = jwtDecode(nextAuthorization) as JwtPayload & {uuid: string};
+      if (!decoded) {
+        console.warn('JWT decode failed');
+        return null;
+      }
+
+      console.log('Session:JWT decoded');
+      (() => {
+        console.log(' - User', decoded.uuid);
+
+        console.log(' - IAT', ...(() => {
+          if (!decoded.iat) {return [decoded.iat];}
+          const iat = moment.unix(decoded.iat);
+          if (!iat.isValid()) {return [decoded.iat];}
+          return [decoded.iat, iat.format(), iat.diff(Date.now(), 'days'), 'days left'];
+        })());
+
+        console.log(' - NBF', ...(() => {
+          if (!decoded.nbf) {return [decoded.nbf];}
+          const nbf = moment.unix(decoded.nbf);
+          if (!nbf.isValid()) {return [decoded.nbf];}
+          return [decoded.nbf, nbf.format(), nbf.diff(Date.now(), 'days'), 'days left'];
+        })());
+
+        console.log(' - EXP', ...(() => {
+          if (!decoded.exp) {return [decoded.exp];}
+          const exp = moment.unix(decoded.exp);
+          if (!exp.isValid()) {return [decoded.exp];}
+          return [decoded.exp, exp.format(), exp.diff(Date.now(), 'days'), 'days left'];
+        })());
+      })();
+
+      // AsyncStorage 에 토큰 저장
+      await this.storageProvider.set(this.getKey(), nextAuthorization);
+
+      // API Instance header 설정
+      this.api.defaults.headers.common.Authorization = `Bearer ${nextAuthorization}`;
+
+      // Return
+      return nextAuthorization;
+    } catch (e) {
+      console.error(e);
+    }
+    return null;
+  }
+
+  public async removeAuthorization() {
+    // API Instance header 에서 토큰 제거
+    delete this.api.defaults.headers.common.Authorization;
+
+    // 스토리지에서 authorization 제거
+    await this.storageProvider.remove(this.getKey());
+  }
+}
+
+export namespace Session {
+  export enum STORAGE_KEY {
+    SESSION_AUTHORIZATION = 'SESSION_AUTHORIZATION',
+  }
+}

package/src/services/browser.ts

@@ -0,0 +1,5 @@
+// Directories
+export * from './time';
+
+// Files
+export * from './Session';

package/src/services/index.ts

@@ -0,0 +1,4 @@
+export * from './browser';
+
+// Directories
+export * from './redis';

package/src/services/redis/RedisClient.ts

@@ -0,0 +1,79 @@
+import redis, {
+  createClient,
+  RedisClientType,
+  RedisDefaultModules,
+  RedisFunctions,
+  RedisModules,
+  RedisScripts
+} from 'redis';
+
+const LOG_PREFIX = 'RedisClient';
+
+export class RedisClient {
+  private readonly options: RedisClient.RedisClientOptions = {};
+  private status: RedisClient.Status = RedisClient.Status.STOPPED;
+  public readonly client: RedisClientType<RedisDefaultModules & RedisModules, RedisFunctions, RedisScripts>;
+
+  public constructor(options?: RedisClient.RedisClientOptions) {
+    console.log(Date.now(), LOG_PREFIX, 'initialized');
+
+    if (options) {
+      this.options = options;
+    }
+
+    if (options?.redisOptions) {
+      this.client = createClient(options.redisOptions);
+    } else {
+      this.client = createClient({});
+    }
+  }
+
+  public async start(): Promise<RedisClient.Status> {
+    console.log(LOG_PREFIX, 'trying to start');
+
+    // register event callback
+    this.client.on('connect', this.handleOnConnect);
+    this.client.on('error', this.handleOnError);
+
+    await this.client.connect();
+
+    this.status = RedisClient.Status.RUNNING;
+    console.log(LOG_PREFIX, 'now started');
+    return this.status;
+  }
+
+  public async stop(): Promise<RedisClient.Status> {
+    console.log(LOG_PREFIX, 'trying to stop');
+
+    // unregister event callback
+    this.client.off('connect', this.handleOnConnect);
+    this.client.off('error', this.handleOnError);
+
+    if (this.client.isOpen) {
+      await this.client.disconnect();
+    }
+
+    this.status = RedisClient.Status.STOPPED;
+    console.log(LOG_PREFIX, 'now stopped');
+    return this.status;
+  }
+
+  private handleOnConnect() {
+    console.log(LOG_PREFIX, 'connected');
+  }
+
+  private handleOnError(error: Error) {
+    console.error(LOG_PREFIX, error);
+  }
+}
+
+export namespace RedisClient {
+  export enum Status {
+    RUNNING,
+    STOPPED,
+  }
+
+  export interface RedisClientOptions {
+    redisOptions?: redis.RedisClientOptions;
+  }
+}

package/src/services/redis/RedisPublisher.ts

@@ -0,0 +1,48 @@
+import {RedisClient} from "./RedisClient";
+
+export class RedisPublisher extends RedisClient {
+  private logging: RedisPublisher.LOGGING = 'length';
+
+  public constructor(options?: RedisClient.RedisClientOptions) {
+    super(options);
+    console.log(Date.now(), "RedisPublisher", 'initialized');
+  }
+
+  public async start(): Promise<RedisClient.Status> {
+    return await super.start();
+  }
+
+  public async stop(): Promise<RedisClient.Status> {
+    return await super.stop();
+  }
+
+  public setLogging(logging: RedisPublisher.LOGGING) {
+    this.logging = logging;
+  }
+
+  public getLogging(): RedisPublisher.LOGGING {
+    return this.logging;
+  }
+
+  // Make public method
+  public publish = async (channel: string, data: string | object) => {
+    const stringifyData = typeof data !== 'string' ? JSON.stringify(data) : data;
+
+    switch (this.logging) {
+      case "none": {break;}
+      case "length": {
+        console.log(Date.now(), 'Server ---> Redis', channel, stringifyData.length);
+        break;
+      }
+      case "data": {
+        console.log(Date.now(), 'Server ---> Redis', channel, stringifyData);
+        break;
+      }
+    }
+    await this.client.publish(channel, stringifyData);
+  }
+}
+
+export namespace RedisPublisher {
+  export type LOGGING = 'none' | 'length' | 'data';
+}