@aptana/multichannel-common 2.9.12

package/core/errors/RequestValidationError.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestValidationError = void 0;
+const AppError_1 = require("../../core/errors/AppError");
+class RequestValidationError extends AppError_1.AppError {
+    errors;
+    constructor(errors) {
+        super('Unprocessable Content', 422);
+        this.errors = errors;
+    }
+    serializeErrors() {
+        return this.errors
+            .flatMap((error) => this.mapChildrenToValidationErrors(error))
+            .filter((error) => !!error.constraints && !!Object.entries(error.constraints).length)
+            .flatMap((error) => {
+            return { message: Object.values(error.constraints).join(', '), field: error.property };
+        });
+    }
+    mapChildrenToValidationErrors(error, parentPath) {
+        if (!(error.children && error.children.length)) {
+            return [error];
+        }
+        const validationErrors = [];
+        parentPath = parentPath
+            ? `${parentPath}.${error.property}`
+            : error.property;
+        for (const item of error.children) {
+            if (item.children && item.children.length) {
+                validationErrors.push(...this.mapChildrenToValidationErrors(item, parentPath));
+            }
+            validationErrors.push(this.prependConstraintsWithParentProp(item, parentPath));
+        }
+        return validationErrors;
+    }
+    prependConstraintsWithParentProp(error, parentPath) {
+        const constraints = {};
+        for (const key in error.constraints) {
+            constraints[key] = `${parentPath}.${error.constraints[key]}`;
+        }
+        return {
+            ...error,
+            constraints,
+        };
+    }
+}
+exports.RequestValidationError = RequestValidationError;
+exports.default = RequestValidationError;

package/core/errors/ValidationError.d.ts

@@ -0,0 +1,8 @@
+import { AppError, ErrorMessage } from '../../core/errors/AppError';
+export declare class ValidationError extends AppError {
+    protected errors: ErrorMessage[];
+    constructor(errors: ErrorMessage[]);
+    static with(error: ErrorMessage): ValidationError;
+    serializeErrors(): ErrorMessage[];
+}
+export default ValidationError;

package/core/errors/ValidationError.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationError = void 0;
+const AppError_1 = require("../../core/errors/AppError");
+class ValidationError extends AppError_1.AppError {
+    errors;
+    constructor(errors) {
+        super('Unprocessable Content', 422);
+        this.errors = errors;
+    }
+    static with(error) {
+        return new ValidationError([error]);
+    }
+    serializeErrors() {
+        return this.errors;
+    }
+}
+exports.ValidationError = ValidationError;
+exports.default = ValidationError;

package/core/errors/WrongAuthenticationTokenError.d.ts

@@ -0,0 +1,5 @@
+import { AppError } from '../../core/errors/AppError';
+export declare class WrongAuthenticationTokenError extends AppError {
+    constructor();
+}
+export default WrongAuthenticationTokenError;

package/core/errors/WrongAuthenticationTokenError.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WrongAuthenticationTokenError = void 0;
+const AppError_1 = require("../../core/errors/AppError");
+class WrongAuthenticationTokenError extends AppError_1.AppError {
+    constructor() {
+        super('Authentication token missing', 401);
+    }
+}
+exports.WrongAuthenticationTokenError = WrongAuthenticationTokenError;
+exports.default = WrongAuthenticationTokenError;

package/core/errors/WrongCredentialsError.d.ts

@@ -0,0 +1,5 @@
+import { AppError } from '../../core/errors/AppError';
+export declare class WrongCredentialsError extends AppError {
+    constructor();
+}
+export default WrongCredentialsError;

package/core/errors/WrongCredentialsError.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WrongCredentialsError = void 0;
+const AppError_1 = require("../../core/errors/AppError");
+class WrongCredentialsError extends AppError_1.AppError {
+    constructor() {
+        super('Wrong credentials provided', 401);
+    }
+}
+exports.WrongCredentialsError = WrongCredentialsError;
+exports.default = WrongCredentialsError;

package/core/index.d.ts

@@ -0,0 +1,48 @@
+export * from "../core/domain/Entity";
+export * from "../core/domain/Identifier";
+export * from "../core/domain/UniqueId";
+export * from "../core/domain/UseCase";
+export * from "../core/domain/ValueObject";
+export * from "../core/domain/auth/Auth";
+export * from "../core/domain/auth/Authenticable";
+export * from "../core/domain/auth/Guard";
+export * from "../core/domain/auth/TokenGuard";
+export * from "../core/domain/auth/UserProvider";
+export * from "../core/infrastructure/http/App";
+export * from "../core/infrastructure/events/Event";
+export * from "../core/infrastructure/events/Listener";
+export * from "../core/infrastructure/events/Worker";
+export { Event as EventRpc } from "../core/infrastructure/events/rpc/Event";
+export { Listener as ListenerRpc } from "../core/infrastructure/events/rpc/Listener";
+export { Event as EventGrpc } from "../core/infrastructure/events/grpc/Event";
+export { Listener as ListenerGrpc } from "../core/infrastructure/events/grpc/Listener";
+export * from "../core/infrastructure/Container";
+export * from "../core/infrastructure/Controller";
+export * from "../core/infrastructure/Mapper";
+export * from "../core/infrastructure/Repo";
+export * from "../core/infrastructure/DatabaseRepository";
+export * from "../core/infrastructure/loaders/Loader";
+export * from "../core/infrastructure/loaders/Manager";
+export * from "../core/infrastructure/cache/Cache";
+/**
+ * @deprecated
+ */
+export * from "../core/infrastructure/cache/InMemoryCache";
+export * from "../core/infrastructure/cache/RedisCache";
+export * from "../core/errors/AppError";
+export * from "../core/errors/AuthenticationTokenMissingError";
+export * from "../core/errors/BadRequestError";
+export * from "../core/errors/NotAuthorizedError";
+export * from "../core/errors/NotFoundError";
+export * from "../core/errors/RequestValidationError";
+export * from "../core/errors/ValidationError";
+export * from "../core/errors/WrongAuthenticationTokenError";
+export * from "../core/errors/WrongCredentialsError";
+export * from "../core/utils/Hash";
+export * from "../core/utils/Crypto";
+export * from "../core/utils/commands";
+export * from "../core/utils/events";
+export * from "../core/utils/logger";
+export * from "../core/utils/response";
+export * from "../core/utils/validator";
+export * from "../core/utils/cache";

package/core/index.js

@@ -0,0 +1,69 @@
+"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 });
+exports.ListenerGrpc = exports.EventGrpc = exports.ListenerRpc = exports.EventRpc = void 0;
+__exportStar(require("../core/domain/Entity"), exports);
+__exportStar(require("../core/domain/Identifier"), exports);
+__exportStar(require("../core/domain/UniqueId"), exports);
+__exportStar(require("../core/domain/UseCase"), exports);
+__exportStar(require("../core/domain/ValueObject"), exports);
+__exportStar(require("../core/domain/auth/Auth"), exports);
+__exportStar(require("../core/domain/auth/Authenticable"), exports);
+__exportStar(require("../core/domain/auth/Guard"), exports);
+__exportStar(require("../core/domain/auth/TokenGuard"), exports);
+__exportStar(require("../core/domain/auth/UserProvider"), exports);
+__exportStar(require("../core/infrastructure/http/App"), exports);
+__exportStar(require("../core/infrastructure/events/Event"), exports);
+__exportStar(require("../core/infrastructure/events/Listener"), exports);
+__exportStar(require("../core/infrastructure/events/Worker"), exports);
+var Event_1 = require("../core/infrastructure/events/rpc/Event");
+Object.defineProperty(exports, "EventRpc", { enumerable: true, get: function () { return Event_1.Event; } });
+var Listener_1 = require("../core/infrastructure/events/rpc/Listener");
+Object.defineProperty(exports, "ListenerRpc", { enumerable: true, get: function () { return Listener_1.Listener; } });
+var Event_2 = require("../core/infrastructure/events/grpc/Event");
+Object.defineProperty(exports, "EventGrpc", { enumerable: true, get: function () { return Event_2.Event; } });
+var Listener_2 = require("../core/infrastructure/events/grpc/Listener");
+Object.defineProperty(exports, "ListenerGrpc", { enumerable: true, get: function () { return Listener_2.Listener; } });
+__exportStar(require("../core/infrastructure/Container"), exports);
+__exportStar(require("../core/infrastructure/Controller"), exports);
+__exportStar(require("../core/infrastructure/Mapper"), exports);
+__exportStar(require("../core/infrastructure/Repo"), exports);
+__exportStar(require("../core/infrastructure/DatabaseRepository"), exports);
+__exportStar(require("../core/infrastructure/loaders/Loader"), exports);
+__exportStar(require("../core/infrastructure/loaders/Manager"), exports);
+__exportStar(require("../core/infrastructure/cache/Cache"), exports);
+/**
+ * @deprecated
+ */
+__exportStar(require("../core/infrastructure/cache/InMemoryCache"), exports);
+__exportStar(require("../core/infrastructure/cache/RedisCache"), exports);
+__exportStar(require("../core/errors/AppError"), exports);
+__exportStar(require("../core/errors/AuthenticationTokenMissingError"), exports);
+__exportStar(require("../core/errors/BadRequestError"), exports);
+__exportStar(require("../core/errors/NotAuthorizedError"), exports);
+__exportStar(require("../core/errors/NotFoundError"), exports);
+__exportStar(require("../core/errors/RequestValidationError"), exports);
+__exportStar(require("../core/errors/ValidationError"), exports);
+__exportStar(require("../core/errors/WrongAuthenticationTokenError"), exports);
+__exportStar(require("../core/errors/WrongCredentialsError"), exports);
+__exportStar(require("../core/utils/Hash"), exports);
+__exportStar(require("../core/utils/Crypto"), exports);
+__exportStar(require("../core/utils/commands"), exports);
+__exportStar(require("../core/utils/events"), exports);
+__exportStar(require("../core/utils/logger"), exports);
+__exportStar(require("../core/utils/response"), exports);
+__exportStar(require("../core/utils/validator"), exports);
+__exportStar(require("../core/utils/cache"), exports);

package/core/infrastructure/Container.d.ts

@@ -0,0 +1 @@
+export { Container, ContainerInstance, Service, Inject } from 'typedi';

package/core/infrastructure/Container.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Inject = exports.Service = exports.ContainerInstance = exports.Container = void 0;
+var typedi_1 = require("typedi");
+Object.defineProperty(exports, "Container", { enumerable: true, get: function () { return typedi_1.Container; } });
+Object.defineProperty(exports, "ContainerInstance", { enumerable: true, get: function () { return typedi_1.ContainerInstance; } });
+Object.defineProperty(exports, "Service", { enumerable: true, get: function () { return typedi_1.Service; } });
+Object.defineProperty(exports, "Inject", { enumerable: true, get: function () { return typedi_1.Inject; } });

package/core/infrastructure/Controller.d.ts

@@ -0,0 +1,9 @@
+import { Response, Router } from 'express';
+export declare abstract class Controller {
+    router: Router;
+    constructor();
+    abstract registerRoutes(): void;
+    ok<T>(res: Response, dto?: T): Response<any, Record<string, any>>;
+    created(res: Response): Response<any, Record<string, any>>;
+    fail(res: Response, error: Error | string): void;
+}

package/core/infrastructure/Controller.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Controller = void 0;
+const express_1 = require("express");
+const response_1 = require("../../core/utils/response");
+const AppError_1 = require("../../core/errors/AppError");
+class Controller {
+    router = (0, express_1.Router)();
+    constructor() {
+        this.registerRoutes();
+    }
+    ok(res, dto) {
+        if (!!dto) {
+            return (0, response_1.sendSuccessResponse)(res, dto, 200);
+        }
+        else {
+            return res.sendStatus(200);
+        }
+    }
+    created(res) {
+        return res.sendStatus(201);
+    }
+    fail(res, error) {
+        if (error instanceof Error) {
+            throw error;
+        }
+        throw new AppError_1.AppError(error);
+    }
+}
+exports.Controller = Controller;

package/core/infrastructure/DatabaseRepository.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Interface representing a repository for database operations.
+ */
+export default interface DatabaseRepository {
+    /**
+     * Save an entity to the database.
+     * @param entity - The entity to be saved.
+     * @returns A promise that resolves to the saved entity.
+     */
+    save(entity: any): Promise<any>;
+    /**
+     * Retrieve an entity from the database by its ID.
+     * @param id - The ID of the entity to be retrieved.
+     * @returns A promise that resolves to the retrieved entity.
+     */
+    show(id: string): Promise<any>;
+    /**
+     * List entities from the database based on the provided request.
+     * @param req - The request object containing query pagination parameters.
+     * @returns A promise that resolves to the list of entities.
+     */
+    list(req: any): Promise<any>;
+    /**
+     * Update an entity in the database.
+     * @param entity - The entity with updated values.
+     * @returns A promise that resolves to the updated entity.
+     */
+    update(entity: any): Promise<any>;
+    /**
+     * Delete an entity from the database.
+     * @param id - The ID of the entity to be deleted.
+     * @returns A promise that resolves to the result of the deletion operation.
+     */
+    delete(id: string): Promise<any>;
+}

package/core/infrastructure/DatabaseRepository.js

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

package/core/infrastructure/Mapper.d.ts

@@ -0,0 +1,2 @@
+export declare abstract class Mapper<T> {
+}

package/core/infrastructure/Mapper.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Mapper = void 0;
+class Mapper {
+}
+exports.Mapper = Mapper;

package/core/infrastructure/Repo.d.ts

@@ -0,0 +1,2 @@
+export declare abstract class Repo<T> {
+}

package/core/infrastructure/Repo.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Repo = void 0;
+class Repo {
+}
+exports.Repo = Repo;

package/core/infrastructure/cache/Cache.d.ts

@@ -0,0 +1,47 @@
+import { Repo } from '../../../core/infrastructure/cache/Repo';
+type CacheDriver = 'null' | 'array' | 'file' | 'redis';
+type StoreConfig = {
+    driver: CacheDriver;
+    [key: string]: any;
+};
+export type CacheConfig = {
+    store: string;
+    stores: {
+        [key: string]: StoreConfig;
+    };
+    prefix: string;
+};
+export declare class Cache {
+    protected stores: {
+        [key: string]: Repo;
+    };
+    protected readonly config: CacheConfig;
+    constructor(config: CacheConfig);
+    driver(driver?: CacheDriver): Repo;
+    protected store(name?: string): Repo;
+    protected resolve(name: string): any;
+    protected getConfig(name: string): {
+        driver: string;
+    };
+    protected getPrefix(): string;
+    protected getDefaultDriver(): string;
+    protected nullDriver(config: StoreConfig): Repo;
+    protected arrayDriver(config: StoreConfig): Repo;
+    protected fileDriver(config: StoreConfig): Repo;
+    protected redisDriver(config: StoreConfig): Repo;
+    /**
+     * CacheContract
+     */
+    has(key: string): Promise<boolean>;
+    missing(key: string): Promise<boolean>;
+    get<T>(key: string, _default?: any): Promise<T | null>;
+    pull<T>(key: string, _default?: any): Promise<T | null>;
+    put(key: string, value: any, ttl?: number): Promise<boolean>;
+    add(key: string, value: any, ttl?: number): Promise<boolean>;
+    forever(key: string, value: any): Promise<boolean>;
+    remember<T>(key: string, callback: Function, ttl?: number): Promise<T>;
+    rememberForever<T>(key: string, callback: Function): Promise<T>;
+    forget(key: string): Promise<boolean>;
+    flush(): Promise<boolean>;
+}
+export {};

package/core/infrastructure/cache/Cache.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cache = void 0;
+const ioredis_1 = require("ioredis");
+const Repo_1 = require("../../../core/infrastructure/cache/Repo");
+const NullStore_1 = require("../../../core/infrastructure/cache/stores/NullStore");
+const ArrayStore_1 = require("../../../core/infrastructure/cache/stores/ArrayStore");
+const RedisStore_1 = require("../../../core/infrastructure/cache/stores/RedisStore");
+const FileStore_1 = require("../../../core/infrastructure/cache/stores/FileStore");
+class Cache {
+    stores = {};
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    driver(driver) {
+        return this.store(driver);
+    }
+    store(name) {
+        name = name || this.getDefaultDriver();
+        if (!(name in this.stores)) {
+            this.stores[name] = this.resolve(name);
+        }
+        return this.stores[name];
+    }
+    resolve(name) {
+        const config = this.getConfig(name);
+        if (!config) {
+            throw new Error(`Cache store [${name}] is not defined.`);
+        }
+        const driverMethod = config.driver + 'Driver';
+        if (this[driverMethod]) {
+            return this[driverMethod](config);
+        }
+        throw new Error(`Cache driver [${config.driver}] is not supported.`);
+    }
+    getConfig(name) {
+        if (name && name !== 'null') {
+            return this.config.stores[name];
+        }
+        return { driver: 'null' };
+    }
+    getPrefix() {
+        return this.config.prefix;
+    }
+    getDefaultDriver() {
+        return this.config.store;
+    }
+    nullDriver(config) {
+        return new Repo_1.Repo(new NullStore_1.NullStore());
+    }
+    arrayDriver(config) {
+        return new Repo_1.Repo(new ArrayStore_1.ArrayStore());
+    }
+    fileDriver(config) {
+        const path = config.path || 'storage/cache/data';
+        return new Repo_1.Repo(new FileStore_1.FileStore(path));
+    }
+    redisDriver(config) {
+        const redis = new ioredis_1.Redis(config.redisUrl);
+        const prefix = this.getPrefix();
+        return new Repo_1.Repo(new RedisStore_1.RedisStore(redis, prefix));
+    }
+    /**
+     * CacheContract
+     */
+    async has(key) {
+        return await this.store().has(key);
+    }
+    async missing(key) {
+        return await this.store().missing(key);
+    }
+    async get(key, _default) {
+        return await this.store().get(key, _default);
+    }
+    async pull(key, _default) {
+        return await this.store().pull(key, _default);
+    }
+    async put(key, value, ttl) {
+        return await this.store().put(key, value, ttl);
+    }
+    async add(key, value, ttl) {
+        return await this.store().add(key, value, ttl);
+    }
+    async forever(key, value) {
+        return await this.store().forever(key, value);
+    }
+    async remember(key, callback, ttl) {
+        return await this.store().remember(key, callback, ttl);
+    }
+    async rememberForever(key, callback) {
+        return await this.store().rememberForever(key, callback);
+    }
+    async forget(key) {
+        return await this.store().forget(key);
+    }
+    async flush() {
+        return await this.store().flush();
+    }
+}
+exports.Cache = Cache;

package/core/infrastructure/cache/InMemoryCache.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="node" />
+import { Cache as CacheContract } from '../../../core/domain/cache/Cache';
+type CacheRecord<T> = {
+    data: T;
+    expire: number;
+};
+/**
+ * @deprecated
+ */
+export declare class InMemoryCache implements CacheContract {
+    protected readonly TTL: number;
+    protected readonly store: Map<string, CacheRecord<any>>;
+    protected readonly timeoutRefs: Map<string, NodeJS.Timeout>;
+    constructor();
+    get<T>(key: string): Promise<T | null>;
+    set<T>(key: string, data: T, ttl?: number): Promise<void>;
+    invalidate(key: string): Promise<void>;
+    clear(): Promise<void>;
+}
+export {};

package/core/infrastructure/cache/InMemoryCache.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryCache = void 0;
+const DEFAULT_TTL_IN_SECONDS = 30; // seconds
+/**
+ * @deprecated
+ */
+class InMemoryCache {
+    TTL;
+    store = new Map();
+    timeoutRefs = new Map();
+    constructor() {
+        this.TTL = DEFAULT_TTL_IN_SECONDS;
+    }
+    async get(key) {
+        const now = Date.now();
+        const record = this.store.get(key);
+        const expiration = record?.expire ?? Infinity;
+        if (!record || expiration < now) {
+            return null;
+        }
+        return record.data;
+    }
+    async set(key, data, ttl = this.TTL) {
+        if (ttl === 0) {
+            return;
+        }
+        const record = { data, expire: ttl * 1000 + Date.now() };
+        const oldRecord = this.store.get(key);
+        if (oldRecord) {
+            clearTimeout(this.timeoutRefs.get(key));
+            this.timeoutRefs.delete(key);
+        }
+        const ref = setTimeout(async () => {
+            await this.invalidate(key);
+        }, ttl * 1000);
+        ref.unref();
+        this.timeoutRefs.set(key, ref);
+        this.store.set(key, record);
+    }
+    async invalidate(key) {
+        let keys = [key];
+        if (key.includes("*")) {
+            const regExp = new RegExp(key.replace("*", ".*"));
+            keys = Array.from(this.store.keys()).filter((k) => k.match(regExp));
+        }
+        keys.forEach((key) => {
+            const timeoutRef = this.timeoutRefs.get(key);
+            if (timeoutRef) {
+                clearTimeout(timeoutRef);
+                this.timeoutRefs.delete(key);
+            }
+            this.store.delete(key);
+        });
+    }
+    async clear() {
+        this.timeoutRefs.forEach((ref) => clearTimeout(ref));
+        this.timeoutRefs.clear();
+        this.store.clear();
+    }
+}
+exports.InMemoryCache = InMemoryCache;

package/core/infrastructure/cache/RedisCache.d.ts

@@ -0,0 +1,15 @@
+import { Cache as CacheContract } from '../../../core/domain/cache/Cache';
+import { Redis } from 'ioredis';
+/**
+ * @deprecated
+ */
+export declare class RedisCache implements CacheContract {
+    protected readonly TTL: number;
+    protected readonly redis: Redis;
+    private readonly namespace;
+    constructor();
+    get<T>(key: string): Promise<T | null>;
+    set(key: string, data: Record<string, unknown>, ttl?: number): Promise<void>;
+    invalidate(key: string): Promise<void>;
+    private getCacheKey;
+}

package/core/infrastructure/cache/RedisCache.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisCache = void 0;
+const ioredis_1 = require("ioredis");
+const DEFAULT_NAMESPACE = "waba";
+const DEFAULT_CACHE_TIME_IN_SECONDS = 30;
+const EXPIRY_MODE = "EX";
+/**
+ * @deprecated
+ */
+class RedisCache {
+    TTL;
+    redis;
+    namespace;
+    constructor() {
+        this.redis = new ioredis_1.Redis(process.env.REDIS_URL);
+        this.TTL = DEFAULT_CACHE_TIME_IN_SECONDS;
+        this.namespace = DEFAULT_NAMESPACE;
+    }
+    async get(key) {
+        key = this.getCacheKey(key);
+        try {
+            const cached = await this.redis.get(key);
+            if (cached) {
+                return JSON.parse(cached);
+            }
+        }
+        catch (error) {
+            await this.redis.del(key);
+        }
+        return null;
+    }
+    async set(key, data, ttl = this.TTL) {
+        if (ttl === 0) {
+            return;
+        }
+        await this.redis.set(this.getCacheKey(key), JSON.stringify(data), EXPIRY_MODE, ttl);
+    }
+    async invalidate(key) {
+        const keys = await this.redis.keys(this.getCacheKey(key));
+        const pipeline = this.redis.pipeline();
+        keys.forEach(function (key) {
+            pipeline.del(key);
+        });
+        await pipeline.exec();
+    }
+    getCacheKey(key) {
+        return this.namespace ? `${this.namespace}:${key}` : key;
+    }
+}
+exports.RedisCache = RedisCache;