@ambiten/core 1.0.0

package/dist/middleware/rbac/rbacMiddleware.js

@@ -0,0 +1,246 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkPermission = checkPermission;
+exports.getCachedData = getCachedData;
+exports.setCachedData = setCachedData;
+exports.invalidateTenantCache = invalidateTenantCache;
+exports.enforceRBAC = enforceRBAC;
+exports.getRBACAction = getRBACAction;
+exports.getOriginalResolver = getOriginalResolver;
+const redis_manager_1 = require("../../redis-manager");
+const rbacTypes_1 = require("./rbacTypes");
+function buildCacheKey(role, key) {
+    if (Array.isArray(role)) {
+        return `${role.join(',')}:${key}`;
+    }
+    if (role && typeof role === 'object') {
+        if ('tenantId' in role)
+            return `${role.tenantId}:${key}`;
+        // If role is actually a role object or other shape, fallback to JSON-safe string
+        try {
+            const convertCredentials = JSON.parse(JSON.stringify(role));
+            return `${convertCredentials}:${key}`;
+        }
+        catch (err) {
+            return `${String(role)}:${key}`;
+        }
+    }
+    return `${role}:${key}`;
+}
+;
+// const tenantCache: Map<string, any> = new Map();
+/**
+ * Check if a user has a specific permission
+ * @param role The role of the user
+ * @param permission The permission to check
+ * @returns A promise that resolves to true if the user has the permission, false otherwise
+ * @example
+ * const hasPermission = await checkPermission('admin', 'createUser');
+ * if (hasPermission) {
+ * // User has permission to create a user
+ * } else {
+ * // User does not have permission to create a user
+ * }
+ */
+async function checkPermission(role, permission) {
+    const cacheKey = buildCacheKey(role, 'permissions');
+    let allowedActions = await getCachedData(role, 'permissions');
+    if (!allowedActions) {
+        console.info(`Cache miss for role "${role}". Fetching permissions...`);
+        // Fetch permissions from the rolePermissions object
+        allowedActions = rbacTypes_1.rolePermissions[role] || [];
+        if (allowedActions.length > 0) {
+            console.info(`Permissions found for role "${role}": ${allowedActions.join(', ')}`);
+        }
+        else {
+            console.warn(`No permissions found for role "${role}"`);
+        }
+    }
+    ;
+    const cacheExists = await redis_manager_1.redis.exists(cacheKey);
+    if (cacheExists) {
+        console.info(`Cache hit for role "${role}"`);
+    }
+    // If allowedActions is not already cached, set it
+    if (allowedActions) {
+        allowedActions = Promise.resolve(rbacTypes_1.rolePermissions[role] || []);
+        await setCachedData(role, 'permissions', await allowedActions, 500); // Cache for 500s
+    }
+    return Promise.resolve(rbacTypes_1.rolePermissions[role] || []).then(permissions => {
+        if (permissions.includes(permission)) {
+            console.info(`Permission granted for role "${role}" to perform action "${permission}"`);
+            return true;
+        }
+        else {
+            console.warn(`Permission denied for role "${role}" to perform action "${permission}"`);
+            return false;
+        }
+    });
+}
+/**
+ * Get cached data for a specific role and key
+ * @param role The role or tenant object
+ * @param key The key to retrieve from the cache
+ * @return {Promise<any>} A promise that resolves to the cached data or null if not found
+ * This function retrieves cached data from Redis based on the provided role and key.
+ * It constructs a unique cache key using the role and key, checks if the data exists in the cache,
+ * and returns the parsed data if found. If the data is not found, it logs a cache miss and returns null.
+ * @throws {Error} If there is an issue with the Redis operation
+ * @example
+ * // Get cached permissions for role 'admin'
+ * const cachedPermissions = await getCachedData('admin', 'permissions');
+ * if (cachedPermissions) {
+ *   console.log('Cached permissions:', cachedPermissions);
+ * } else {
+ *  console.log('No cached permissions found');
+ * }
+ */
+async function getCachedData(role, key) {
+    const cacheKey = buildCacheKey(role, key);
+    const cachedData = await redis_manager_1.redis.get(cacheKey);
+    if (cachedData) {
+        console.info(`Cache hit for key "${cacheKey}"`);
+    }
+    else {
+        console.warn(`Cache miss for key "${cacheKey}"`);
+    }
+    try {
+        return cachedData ? JSON.parse(JSON.stringify(cachedData)) : null;
+    }
+    catch (err) {
+        console.warn(`Failed to parse cached data for key ${cacheKey}:`, err);
+        // If parsing fails, return raw value to avoid crashing
+        return cachedData;
+    }
+}
+;
+async function setCachedData(role, key, data, ttl) {
+    // Build a consistent cache key and store JSON-stringified data with TTL
+    const cacheKey = buildCacheKey(role, key);
+    try {
+        await redis_manager_1.redis?.set(cacheKey, JSON.stringify(data), { EX: ttl });
+        console.info(`Cache set for ${cacheKey}:`, data);
+    }
+    catch (err) {
+        console.error(`Failed to set cache for ${cacheKey}:`, err);
+    }
+    // Only log permissions if role is a string or array with values
+    let roleKey;
+    if (typeof role === 'string') {
+        roleKey = role;
+    }
+    else if (Array.isArray(role) && role.length > 0) {
+        roleKey = role[0];
+    }
+    else if (role && typeof role === 'object' && 'tenantId' in role) {
+        roleKey = role.tenantId;
+    }
+    if (roleKey) {
+        const permissions = rbacTypes_1.rolePermissions[roleKey] || [];
+        if (permissions.length > 0) {
+            console.info(`Permissions cached for role "${roleKey}": ${permissions.join(', ')}`);
+        }
+        else {
+            console.warn(`No permissions found for role "${roleKey}" to cache`);
+        }
+    }
+    else {
+        console.warn(`Role key is not a string, cannot cache permissions`);
+    }
+    return;
+}
+/**
+ * Invalidate the cache for a specific tenant and role
+ * @param tenantId The ID of the tenant
+ * @param role The role to invalidate cache for
+ * @return {Promise<void>}
+ * This function removes the cached permissions for the specified tenant and role.
+ * It is useful when permissions change and you want to ensure the cache reflects the latest state.
+ * It logs the invalidation action and deletes the cache entry from Redis.
+ * This is particularly important in multi-tenant applications where each tenant may have different permissions.
+ * @throws {Error} If there is an issue with the Redis operation
+ * @example
+ * // Invalidate cache for tenant 'tenant123' with role 'admin'
+ * await invalidateTenantCache('tenant123', 'admin');
+ */
+async function invalidateTenantCache(tenantId, role) {
+    try {
+        const cacheKey = `${tenantId}:permissions:${role}`;
+        const cacheExists = await redis_manager_1.redis.exists(cacheKey);
+        if (cacheExists) {
+            await redis_manager_1.redis.del(cacheKey);
+            console.info(`Cache invalidated for tenant ${tenantId} and role ${role}`);
+        }
+        else {
+            console.warn(`No cache found for tenant ${tenantId} and role ${role}`);
+        }
+    }
+    catch (error) {
+        console.error(`Error invalidating cache for tenant ${tenantId} and role ${role}:`, error);
+        throw new Error(`Failed to invalidate cache for tenant ${tenantId} and role ${role}`);
+    }
+    return;
+}
+/**
+ * Middleware to enforce RBAC (Role-Based Access Control) on GraphQL resolvers
+ * @param resolver The original resolver function
+ * @param permission The required permission for the action
+ * @returns A wrapped resolver function that checks permissions
+ * @throws {Error} If the user does not have the required permission
+ * @example
+ * // Wrap a resolver with RBAC enforcement
+ * const securedResolver = enforceRBAC(originalResolver, 'createUser');
+ *
+ * // Use the secured resolver in your GraphQL schema
+ * const resolvers = {
+ *   Mutation: {
+ *     createUser: securedResolver,
+ * 	}, };
+ *
+ * In this example, the `enforceRBAC` function wraps the `originalResolver` and checks if the user has the 'createUser' permission before allowing access to the resolver. If the user lacks the required permission, an error is thrown, preventing unauthorized access.
+ * * This middleware is essential for implementing fine-grained access control in GraphQL APIs, ensuring that only authorized users can perform specific actions based on their roles and permissions.
+ * @remarks This function is designed to be used in GraphQL resolvers to enforce role-based access control (RBAC). It checks if the user has the necessary permissions before allowing access to the resolver function. If the user lacks the required permission, an error is thrown, preventing unauthorized access.
+ * * @see {@link checkPermission} for checking user permissions
+ * * @see {@link Role} and {@link Permission} for role and permission types
+ * * @see {@link rolePermissions} for the mapping of roles to permissions
+ * * @see {@link getCachedData} and {@link setCachedData} for caching permissions
+ */
+// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+function enforceRBAC(resolver, permission) {
+    const wrapped = async (parent, args, context, info) => {
+        const { user } = context;
+        // Ensure we pass the user's role (string) and await the async permission check
+        if (!user || !(await checkPermission(user.role, permission))) {
+            throw new Error('Unauthorized: You do not have permission to perform this action.');
+        }
+        return await resolver(parent, args, context, info);
+    };
+    // Preserve function name (useful for logging, debugging)
+    Object.defineProperty(wrapped, 'name', {
+        value: resolver.name || 'anonymous',
+        writable: false,
+        configurable: true,
+    });
+    // Attach metadata
+    wrapped.__originalResolver = resolver;
+    wrapped.__rbacAction = permission;
+    return wrapped;
+}
+/**
+ * Get the RBAC action from a wrapped resolver
+ * @param resolver The wrapped resolver function
+ * @returns The RBAC action
+ */
+// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+function getRBACAction(resolver) {
+    return resolver.__rbacAction || null;
+}
+/**
+ * Get the original resolver function from a wrapped resolver
+ * @param resolver The wrapped resolver function
+ * @returns The original resolver function
+ */
+// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+function getOriginalResolver(resolver) {
+    return resolver.__originalResolver || resolver;
+}

package/dist/middleware/rbac/rbacTypes.d.ts

@@ -0,0 +1,4 @@
+export type Role = 'admin' | 'user' | 'viewer';
+export type Permission = 'create' | 'read' | 'update' | 'delete';
+export declare const rolePermissions: Record<Role, Permission[]>;
+//# sourceMappingURL=rbacTypes.d.ts.map

package/dist/middleware/rbac/rbacTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rbacTypes.d.ts","sourceRoot":"","sources":["../../../src/middleware/rbac/rbacTypes.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,IAAI,GAAG,OAAO,GAAG,MAAM,GAAG,QAAQ,CAAC;AAC/C,MAAM,MAAM,UAAU,GAAG,QAAQ,GAAG,MAAM,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAEjE,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,IAAI,EAAE,UAAU,EAAE,CAItD,CAAC"}

package/dist/middleware/rbac/rbacTypes.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rolePermissions = void 0;
+exports.rolePermissions = {
+    admin: ['create', 'read', 'update', 'delete'],
+    user: ['create', 'read', 'update'],
+    viewer: ['read'],
+};

package/dist/plugins/index.d.ts

@@ -0,0 +1,3 @@
+export * from './softDelete/applySoftDelete';
+export * from './softDelete/types';
+//# sourceMappingURL=index.d.ts.map

package/dist/plugins/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/plugins/index.ts"],"names":[],"mappings":"AAAA,cAAc,8BAA8B,CAAC;AAC7C,cAAc,oBAAoB,CAAC"}

package/dist/plugins/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./softDelete/applySoftDelete"), exports);
+tslib_1.__exportStar(require("./softDelete/types"), exports);

package/dist/plugins/softDelete/applySoftDelete.d.ts

@@ -0,0 +1,5 @@
+import type { Document } from 'mongodb';
+import type { AmbitenModel } from '../../lib-core';
+import type { SoftDeleteOptions } from './types';
+export declare function applySoftDelete<T extends Document>(model: AmbitenModel<T>, opts?: SoftDeleteOptions): AmbitenModel<T>;
+//# sourceMappingURL=applySoftDelete.d.ts.map

package/dist/plugins/softDelete/applySoftDelete.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"applySoftDelete.d.ts","sourceRoot":"","sources":["../../../src/plugins/softDelete/applySoftDelete.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAwB,MAAM,SAAS,CAAC;AAC9D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AACnD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAmEjD,wBAAgB,eAAe,CAAC,CAAC,SAAS,QAAQ,EAChD,KAAK,EAAE,YAAY,CAAC,CAAC,CAAC,EACtB,IAAI,GAAE,iBAAsB,GAC3B,YAAY,CAAC,CAAC,CAAC,CA+GjB"}

package/dist/plugins/softDelete/applySoftDelete.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applySoftDelete = applySoftDelete;
+const DEFAULTS = {
+    field: 'deletedAt',
+    deletedAtField: 'deletedAt',
+    deletedByField: 'deletedBy',
+    isDeletedField: 'isDeleted',
+    enabled: true,
+    excludeDeletedByDefault: true
+};
+function buildNotDeletedFilter(options) {
+    return {
+        $and: [
+            {
+                $or: [
+                    { [options.deletedAtField]: { $exists: false } },
+                    { [options.deletedAtField]: null }
+                ]
+            },
+            {
+                $or: [
+                    { [options.isDeletedField]: { $exists: false } },
+                    { [options.isDeletedField]: false }
+                ]
+            }
+        ]
+    };
+}
+function buildOnlyDeletedFilter(options) {
+    return {
+        $or: [
+            { [options.deletedAtField]: { $ne: null } },
+            { [options.isDeletedField]: true }
+        ]
+    };
+}
+function mergeFilter(original, extra) {
+    if (!original || Object.keys(original).length === 0) {
+        return extra;
+    }
+    return {
+        $and: [original, extra]
+    };
+}
+function buildSoftDeleteUpdate(options) {
+    return {
+        $set: {
+            [options.deletedAtField]: new Date(),
+            [options.isDeletedField]: true
+        }
+    };
+}
+function applySoftDelete(model, opts = {}) {
+    const options = { ...DEFAULTS, ...opts };
+    if (!options.enabled) {
+        return model;
+    }
+    const applyReadFilter = (ctx) => {
+        if (ctx.withDeleted === true) {
+            return;
+        }
+        if (ctx.onlyDeleted === true) {
+            ctx.filter = mergeFilter(ctx.filter, buildOnlyDeletedFilter(options));
+            return;
+        }
+        if (options.excludeDeletedByDefault) {
+            ctx.filter = mergeFilter(ctx.filter, buildNotDeletedFilter(options));
+        }
+    };
+    model.beforeFind((ctx) => {
+        applyReadFilter(ctx);
+    });
+    model.beforeFindOne((ctx) => {
+        applyReadFilter(ctx);
+    });
+    model.beforeFindOneAndUpdate((ctx) => {
+        applyReadFilter(ctx);
+    });
+    model.beforeFindOneAndReplace((ctx) => {
+        applyReadFilter(ctx);
+    });
+    model.beforeFindOneAndUpsert((ctx) => {
+        applyReadFilter(ctx);
+    });
+    model.beforeAggregate((ctx) => {
+        if (ctx.withDeleted === true) {
+            return;
+        }
+        const stage = ctx.onlyDeleted === true
+            ? { $match: buildOnlyDeletedFilter(options) }
+            : options.excludeDeletedByDefault
+                ? { $match: buildNotDeletedFilter(options) }
+                : null;
+        if (!stage) {
+            return;
+        }
+        ctx.pipeline = [stage, ...(ctx.pipeline ?? [])];
+    });
+    model.beforeDeleteOne((ctx) => {
+        if (ctx.hardDelete === true) {
+            return;
+        }
+        ctx.filter = mergeFilter(ctx.filter, buildNotDeletedFilter(options));
+        ctx.update = buildSoftDeleteUpdate(options);
+        ctx.meta = {
+            ...(ctx.meta ?? {}),
+            softDelete: true
+        };
+    });
+    model.beforeDeleteMany((ctx) => {
+        if (ctx.hardDelete === true) {
+            return;
+        }
+        ctx.filter = mergeFilter(ctx.filter, buildNotDeletedFilter(options));
+        ctx.update = buildSoftDeleteUpdate(options);
+        ctx.meta = {
+            ...(ctx.meta ?? {}),
+            softDelete: true
+        };
+    });
+    model.beforeFindOneAndDelete((ctx) => {
+        ctx.filter = mergeFilter(ctx.filter, buildNotDeletedFilter(options));
+        if (ctx.hardDelete === true) {
+            return;
+        }
+        ctx.update = buildSoftDeleteUpdate(options);
+        ctx.meta = {
+            ...(ctx.meta ?? {}),
+            softDelete: true
+        };
+    });
+    model.setSoftDeleteConfig({
+        deletedAtField: options.deletedAtField,
+        isDeletedField: options.isDeletedField
+    });
+    return model;
+}
+;

package/dist/plugins/softDelete/types.d.ts

@@ -0,0 +1,14 @@
+export interface SoftDeleteOptions {
+    field?: string;
+    deletedAtField?: string;
+    deletedByField?: string;
+    isDeletedField?: string;
+    enabled?: boolean;
+    excludeDeletedByDefault?: boolean;
+}
+export interface SoftDeletableDocument extends Document {
+    deletedAt?: Date | null;
+    isDeleted?: boolean;
+    deletedBy?: string | null;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/plugins/softDelete/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/plugins/softDelete/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,iBAAiB;IAChC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,uBAAuB,CAAC,EAAE,OAAO,CAAC;CACnC;AAED,MAAM,WAAW,qBAAsB,SAAQ,QAAQ;IACrD,SAAS,CAAC,EAAE,IAAI,GAAG,IAAI,CAAC;IACxB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3B"}

package/dist/plugins/softDelete/types.js

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

package/dist/redis-manager/index.d.ts

@@ -0,0 +1,2 @@
+export * from './redisClient';
+//# sourceMappingURL=index.d.ts.map

package/dist/redis-manager/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/redis-manager/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC"}

package/dist/redis-manager/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./redisClient"), exports);

package/dist/redis-manager/redisClient.d.ts

@@ -0,0 +1,32 @@
+import 'dotenv/config';
+type AmbitenRedisClient = {
+    isOpen: boolean;
+    connect(): Promise<any>;
+    disconnect(): Promise<any>;
+    quit?: () => Promise<any>;
+    publish(channel: string, message: string): Promise<any>;
+    subscribe(channel: string, listener: any): Promise<any>;
+    duplicate(): AmbitenRedisClient;
+    get(key: string): Promise<string | null>;
+    set(key: string, value: any, options?: any): Promise<any>;
+    del(...keys: string[]): Promise<number>;
+    exists(key: string): Promise<number>;
+    scan(cursor?: number | string, options?: any): Promise<any>;
+    multi(): any;
+};
+type RedisLike = AmbitenRedisClient & {
+    isOpen: boolean;
+    scan?: (...args: any[]) => Promise<any>;
+};
+export declare const redis: any;
+export declare class RedisService {
+    static getInstance(): RedisService;
+    connect(url?: string): Promise<void>;
+    getClient(): Promise<RedisLike>;
+    close(): Promise<void>;
+}
+export declare function connectRedis(): Promise<{
+    connect: (url?: string) => Promise<any>;
+}>;
+export {};
+//# sourceMappingURL=redisClient.d.ts.map

package/dist/redis-manager/redisClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redisClient.d.ts","sourceRoot":"","sources":["../../src/redis-manager/redisClient.ts"],"names":[],"mappings":"AAAA,OAAO,eAAe,CAAC;AAIvB,KAAK,kBAAkB,GAAG;IACxB,MAAM,EAAE,OAAO,CAAC;IAChB,OAAO,IAAI,OAAO,CAAC,GAAG,CAAC,CAAC;IACxB,UAAU,IAAI,OAAO,CAAC,GAAG,CAAC,CAAC;IAC3B,IAAI,CAAC,EAAE,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC;IAC1B,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;IACxD,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;IACxD,SAAS,IAAI,kBAAkB,CAAC;IAChC,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IACzC,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;IAC1D,GAAG,CAAC,GAAG,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IACxC,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IACrC,IAAI,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;IAC5D,KAAK,IAAI,GAAG,CAAC;CACd,CAAC;AASF,KAAK,SAAS,GAAG,kBAAkB,GAAG;IACpC,MAAM,EAAE,OAAO,CAAC;IAChB,IAAI,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;CACzC,CAAC;AAiCF,eAAO,MAAM,KAAK,EAAE,GAkHnB,CAAC;AAEF,qBAAa,YAAY;IACvB,MAAM,CAAC,WAAW,IAAI,YAAY;IAI5B,OAAO,CAAC,GAAG,CAAC,EAAE,MAAM;IAI1B,SAAS,IAAI,OAAO,CAAC,SAAS,CAAC;IAIzB,KAAK;CAGZ;AAED,wBAAsB,YAAY;oBAER,MAAM;GAE/B"}

package/dist/redis-manager/redisClient.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisService = exports.redis = void 0;
+exports.connectRedis = connectRedis;
+require("dotenv/config");
+const redis_1 = require("redis");
+const DEFAULT_RECONNECT = (retries) => Math.min(retries * 50, 1000);
+const redisUrl = process.env.REDIS_URI;
+let currentClient = null;
+const createStub = () => ({
+    isOpen: false,
+    connect: async () => null,
+    disconnect: async () => null,
+    publish: async () => 0,
+    subscribe: async () => null,
+    duplicate: () => createStub(),
+    get: async () => null,
+    set: async () => 'OK',
+    del: async () => 0,
+    exists: async () => 0,
+    scan: async () => ({
+        cursor: 0,
+        keys: [],
+    }),
+    multi: () => ({
+        incr() {
+            return this;
+        },
+        expire() {
+            return this;
+        },
+        exec: async () => [],
+    }),
+});
+exports.redis = {
+    async getClient(uri) {
+        if (currentClient && currentClient.isOpen) {
+            return currentClient;
+        }
+        const url = uri || redisUrl;
+        if (!url) {
+            return createStub();
+        }
+        try {
+            const client = (0, redis_1.createClient)({
+                url,
+                socket: {
+                    reconnectStrategy: DEFAULT_RECONNECT,
+                },
+            });
+            await client.connect();
+            currentClient = client;
+            return client;
+        }
+        catch {
+            return createStub();
+        }
+    },
+    async disconnect() {
+        if (currentClient) {
+            try {
+                if (currentClient.isOpen &&
+                    typeof currentClient.disconnect === 'function') {
+                    await currentClient.disconnect();
+                }
+                else if (currentClient.isOpen &&
+                    typeof currentClient.quit === 'function') {
+                    await currentClient.quit();
+                }
+            }
+            catch {
+                // swallow disconnect errors
+            }
+        }
+        currentClient = null;
+    },
+    get isOpen() {
+        return !!currentClient?.isOpen;
+    },
+    async get(key) {
+        const client = await this.getClient();
+        return client.get?.(key);
+    },
+    async set(key, value, options) {
+        const client = await this.getClient();
+        return client.set?.(key, value, options);
+    },
+    async del(...keys) {
+        const client = await this.getClient();
+        return client.del?.(keys);
+    },
+    async exists(key) {
+        const client = await this.getClient();
+        return client.exists?.(key);
+    },
+    async scan(cursor = 0, options) {
+        const client = await this.getClient();
+        if (typeof client.scan !== 'function') {
+            return {
+                cursor: 0,
+                keys: [],
+            };
+        }
+        return client.scan(cursor, options);
+    },
+    async publish(channel, message) {
+        const client = await this.getClient();
+        return client.publish?.(channel, message);
+    },
+    async subscribe(channel, listener) {
+        const client = await this.getClient();
+        return client.subscribe?.(channel, listener);
+    },
+    duplicate() {
+        if (currentClient?.duplicate) {
+            return currentClient.duplicate();
+        }
+        return createStub();
+    },
+    multi() {
+        if (currentClient?.multi) {
+            return currentClient.multi();
+        }
+        return createStub().multi?.();
+    },
+};
+class RedisService {
+    static getInstance() {
+        return new RedisService();
+    }
+    async connect(url) {
+        await exports.redis.getClient(url);
+    }
+    getClient() {
+        return exports.redis.getClient();
+    }
+    async close() {
+        await exports.redis.disconnect();
+    }
+}
+exports.RedisService = RedisService;
+async function connectRedis() {
+    return {
+        connect: async (url) => exports.redis.getClient(url),
+    };
+}