lapeh 2.3.6 → 2.3.8

package/dist/src/controllers/rbacController.js

@@ -0,0 +1,437 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRole = createRole;
+exports.listRoles = listRoles;
+exports.updateRole = updateRole;
+exports.deleteRole = deleteRole;
+exports.createPermission = createPermission;
+exports.listPermissions = listPermissions;
+exports.updatePermission = updatePermission;
+exports.deletePermission = deletePermission;
+exports.assignRoleToUser = assignRoleToUser;
+exports.removeRoleFromUser = removeRoleFromUser;
+exports.assignPermissionToRole = assignPermissionToRole;
+exports.removePermissionFromRole = removePermissionFromRole;
+exports.assignPermissionToUser = assignPermissionToUser;
+exports.removePermissionFromUser = removePermissionFromUser;
+const database_1 = require("../../lib/core/database");
+const response_1 = require("../../lib/utils/response");
+const validator_1 = require("../../lib/utils/validator");
+const zod_1 = require("zod");
+const serializer_1 = require("../../lib/core/serializer");
+// --- Serializers ---
+const roleSchema = {
+    type: "object",
+    properties: {
+        id: { type: "string" },
+        name: { type: "string" },
+        slug: { type: "string" },
+        description: { type: "string", nullable: true },
+        created_at: { type: "string", format: "date-time", nullable: true },
+        updated_at: { type: "string", format: "date-time", nullable: true },
+    },
+};
+const permissionSchema = {
+    type: "object",
+    properties: {
+        id: { type: "string" },
+        name: { type: "string" },
+        slug: { type: "string" },
+        description: { type: "string", nullable: true },
+        created_at: { type: "string", format: "date-time", nullable: true },
+        updated_at: { type: "string", format: "date-time", nullable: true },
+    },
+};
+const roleSerializer = (0, serializer_1.getSerializer)("role", (0, serializer_1.createResponseSchema)(roleSchema));
+const roleListSerializer = (0, serializer_1.getSerializer)("role-list", (0, serializer_1.createResponseSchema)({ type: "array", items: roleSchema }));
+const permissionSerializer = (0, serializer_1.getSerializer)("permission", (0, serializer_1.createResponseSchema)(permissionSchema));
+const permissionListSerializer = (0, serializer_1.getSerializer)("permission-list", (0, serializer_1.createResponseSchema)({ type: "array", items: permissionSchema }));
+const voidSerializer = (0, serializer_1.getSerializer)("void", (0, serializer_1.createResponseSchema)({ type: "null" }));
+// --- Controllers ---
+async function createRole(req, res) {
+    const validator = validator_1.Validator.make(req.body || {}, {
+        name: "required|string|min:1",
+        slug: "required|string|min:1|unique:roles,slug",
+        description: "string",
+    });
+    if (await validator.fails()) {
+        (0, response_1.sendError)(res, 422, "Validation error", validator.errors());
+        return;
+    }
+    const { name, slug, description } = await validator.validated();
+    // Manual unique check removed as it is handled by validator
+    const role = await database_1.prisma.roles.create({
+        data: {
+            name,
+            slug,
+            description: description || null,
+            created_at: new Date(),
+            updated_at: new Date(),
+        },
+    });
+    (0, response_1.sendFastSuccess)(res, 201, roleSerializer, {
+        status: "success",
+        message: "Role created",
+        data: { ...role, id: role.id.toString() },
+    });
+}
+async function listRoles(_req, res) {
+    const roles = await database_1.prisma.roles.findMany({
+        orderBy: { id: "asc" },
+    });
+    const serialized = roles.map((r) => ({ ...r, id: r.id.toString() }));
+    (0, response_1.sendFastSuccess)(res, 200, roleListSerializer, {
+        status: "success",
+        message: "Roles list",
+        data: serialized,
+    });
+}
+async function updateRole(req, res) {
+    const { id } = req.params;
+    const roleId = BigInt(id);
+    const validator = validator_1.Validator.make(req.body || {}, {
+        name: "string",
+        slug: `string|unique:roles,slug,${id}`,
+        description: "string",
+    });
+    if (await validator.fails()) {
+        (0, response_1.sendError)(res, 422, "Validation error", validator.errors());
+        return;
+    }
+    const { name, slug, description } = await validator.validated();
+    const role = await database_1.prisma.roles.findUnique({ where: { id: roleId } });
+    if (!role) {
+        (0, response_1.sendError)(res, 404, "Role not found");
+        return;
+    }
+    // Manual unique check removed as it is handled by validator
+    const updated = await database_1.prisma.roles.update({
+        where: { id: roleId },
+        data: {
+            name: name ?? role.name,
+            slug: slug ?? role.slug,
+            description: description ?? role.description,
+            updated_at: new Date(),
+        },
+    });
+    (0, response_1.sendFastSuccess)(res, 200, roleSerializer, {
+        status: "success",
+        message: "Role updated",
+        data: { ...updated, id: updated.id.toString() },
+    });
+}
+async function deleteRole(req, res) {
+    const { id } = req.params;
+    const roleId = BigInt(id);
+    const role = await database_1.prisma.roles.findUnique({ where: { id: roleId } });
+    if (!role) {
+        (0, response_1.sendError)(res, 404, "Role not found");
+        return;
+    }
+    await database_1.prisma.role_permissions.deleteMany({ where: { role_id: roleId } });
+    await database_1.prisma.user_roles.deleteMany({ where: { role_id: roleId } });
+    await database_1.prisma.roles.delete({ where: { id: roleId } });
+    (0, response_1.sendFastSuccess)(res, 200, voidSerializer, {
+        status: "success",
+        message: "Role deleted",
+        data: null,
+    });
+}
+async function createPermission(req, res) {
+    const validator = validator_1.Validator.make(req.body || {}, {
+        name: "required|string|min:1",
+        slug: "required|string|min:1|unique:permissions,slug",
+        description: "string",
+    });
+    if (await validator.fails()) {
+        (0, response_1.sendError)(res, 422, "Validation error", validator.errors());
+        return;
+    }
+    const { name, slug, description } = await validator.validated();
+    // Manual unique check removed as it is handled by validator
+    const permission = await database_1.prisma.permissions.create({
+        data: {
+            name,
+            slug,
+            description: description || null,
+            created_at: new Date(),
+            updated_at: new Date(),
+        },
+    });
+    (0, response_1.sendFastSuccess)(res, 201, permissionSerializer, {
+        status: "success",
+        message: "Permission created",
+        data: { ...permission, id: permission.id.toString() },
+    });
+}
+async function listPermissions(_req, res) {
+    const permissions = await database_1.prisma.permissions.findMany({
+        orderBy: { id: "asc" },
+    });
+    const serialized = permissions.map((p) => ({
+        ...p,
+        id: p.id.toString(),
+    }));
+    (0, response_1.sendFastSuccess)(res, 200, permissionListSerializer, {
+        status: "success",
+        message: "Permissions list",
+        data: serialized,
+    });
+}
+async function updatePermission(req, res) {
+    const { id } = req.params;
+    const permissionId = BigInt(id);
+    const validator = validator_1.Validator.make(req.body || {}, {
+        name: "string",
+        slug: `string|unique:permissions,slug,${id}`,
+        description: "string",
+    });
+    if (await validator.fails()) {
+        (0, response_1.sendError)(res, 422, "Validation error", validator.errors());
+        return;
+    }
+    const { name, slug, description } = await validator.validated();
+    const permission = await database_1.prisma.permissions.findUnique({
+        where: { id: permissionId },
+    });
+    if (!permission) {
+        (0, response_1.sendError)(res, 404, "Permission not found");
+        return;
+    }
+    // Manual unique check removed as it is handled by validator
+    const updated = await database_1.prisma.permissions.update({
+        where: { id: permissionId },
+        data: {
+            name: name ?? permission.name,
+            slug: slug ?? permission.slug,
+            description: description ?? permission.description,
+            updated_at: new Date(),
+        },
+    });
+    (0, response_1.sendFastSuccess)(res, 200, permissionSerializer, {
+        status: "success",
+        message: "Permission updated",
+        data: { ...updated, id: updated.id.toString() },
+    });
+}
+async function deletePermission(req, res) {
+    const { id } = req.params;
+    const permissionId = BigInt(id);
+    const permission = await database_1.prisma.permissions.findUnique({
+        where: { id: permissionId },
+    });
+    if (!permission) {
+        (0, response_1.sendError)(res, 404, "Permission not found");
+        return;
+    }
+    await database_1.prisma.role_permissions.deleteMany({
+        where: { permission_id: permissionId },
+    });
+    await database_1.prisma.user_permissions.deleteMany({
+        where: { permission_id: permissionId },
+    });
+    await database_1.prisma.permissions.delete({ where: { id: permissionId } });
+    (0, response_1.sendFastSuccess)(res, 200, voidSerializer, {
+        status: "success",
+        message: "Permission deleted",
+        data: null,
+    });
+}
+async function assignRoleToUser(req, res) {
+    const validator = validator_1.Validator.make(req.body || {}, {
+        userId: zod_1.z.string().min(1, "userId wajib diisi"),
+        roleId: zod_1.z.string().min(1, "roleId wajib diisi"),
+    });
+    if (await validator.fails()) {
+        (0, response_1.sendError)(res, 422, "Validation error", validator.errors());
+        return;
+    }
+    const { userId, roleId } = await validator.validated();
+    const user = await database_1.prisma.users.findUnique({
+        where: { id: BigInt(userId) },
+    });
+    if (!user) {
+        (0, response_1.sendError)(res, 404, "User not found");
+        return;
+    }
+    const role = await database_1.prisma.roles.findUnique({
+        where: { id: BigInt(roleId) },
+    });
+    if (!role) {
+        (0, response_1.sendError)(res, 404, "Role not found");
+        return;
+    }
+    await database_1.prisma.user_roles.upsert({
+        where: {
+            user_id_role_id: {
+                user_id: BigInt(userId),
+                role_id: BigInt(roleId),
+            },
+        },
+        create: {
+            user_id: BigInt(userId),
+            role_id: BigInt(roleId),
+            created_at: new Date(),
+        },
+        update: {},
+    });
+    (0, response_1.sendFastSuccess)(res, 200, voidSerializer, {
+        status: "success",
+        message: "Role assigned to user",
+        data: null,
+    });
+}
+async function removeRoleFromUser(req, res) {
+    const validator = validator_1.Validator.make(req.body || {}, {
+        userId: zod_1.z.string().min(1, "userId wajib diisi"),
+        roleId: zod_1.z.string().min(1, "roleId wajib diisi"),
+    });
+    if (await validator.fails()) {
+        (0, response_1.sendError)(res, 422, "Validation error", validator.errors());
+        return;
+    }
+    const { userId, roleId } = await validator.validated();
+    await database_1.prisma.user_roles.deleteMany({
+        where: {
+            user_id: BigInt(userId),
+            role_id: BigInt(roleId),
+        },
+    });
+    (0, response_1.sendFastSuccess)(res, 200, voidSerializer, {
+        status: "success",
+        message: "Role removed from user",
+        data: null,
+    });
+}
+async function assignPermissionToRole(req, res) {
+    const validator = validator_1.Validator.make(req.body || {}, {
+        roleId: zod_1.z.string().min(1, "roleId wajib diisi"),
+        permissionId: zod_1.z.string().min(1, "permissionId wajib diisi"),
+    });
+    if (await validator.fails()) {
+        (0, response_1.sendError)(res, 422, "Validation error", validator.errors());
+        return;
+    }
+    const { roleId, permissionId } = await validator.validated();
+    const role = await database_1.prisma.roles.findUnique({
+        where: { id: BigInt(roleId) },
+    });
+    if (!role) {
+        (0, response_1.sendError)(res, 404, "Role not found");
+        return;
+    }
+    const permission = await database_1.prisma.permissions.findUnique({
+        where: { id: BigInt(permissionId) },
+    });
+    if (!permission) {
+        (0, response_1.sendError)(res, 404, "Permission not found");
+        return;
+    }
+    await database_1.prisma.role_permissions.upsert({
+        where: {
+            role_id_permission_id: {
+                role_id: BigInt(roleId),
+                permission_id: BigInt(permissionId),
+            },
+        },
+        create: {
+            role_id: BigInt(roleId),
+            permission_id: BigInt(permissionId),
+            created_at: new Date(),
+        },
+        update: {},
+    });
+    (0, response_1.sendFastSuccess)(res, 200, voidSerializer, {
+        status: "success",
+        message: "Permission assigned to role",
+        data: null,
+    });
+}
+async function removePermissionFromRole(req, res) {
+    const validator = validator_1.Validator.make(req.body || {}, {
+        roleId: zod_1.z.string().min(1, "roleId wajib diisi"),
+        permissionId: zod_1.z.string().min(1, "permissionId wajib diisi"),
+    });
+    if (await validator.fails()) {
+        (0, response_1.sendError)(res, 422, "Validation error", validator.errors());
+        return;
+    }
+    const { roleId, permissionId } = await validator.validated();
+    await database_1.prisma.role_permissions.deleteMany({
+        where: {
+            role_id: BigInt(roleId),
+            permission_id: BigInt(permissionId),
+        },
+    });
+    (0, response_1.sendFastSuccess)(res, 200, voidSerializer, {
+        status: "success",
+        message: "Permission removed from role",
+        data: null,
+    });
+}
+async function assignPermissionToUser(req, res) {
+    const validator = validator_1.Validator.make(req.body || {}, {
+        userId: zod_1.z.string().min(1, "userId wajib diisi"),
+        permissionId: zod_1.z.string().min(1, "permissionId wajib diisi"),
+    });
+    if (await validator.fails()) {
+        (0, response_1.sendError)(res, 422, "Validation error", validator.errors());
+        return;
+    }
+    const { userId, permissionId } = await validator.validated();
+    const user = await database_1.prisma.users.findUnique({
+        where: { id: BigInt(userId) },
+    });
+    if (!user) {
+        (0, response_1.sendError)(res, 404, "User not found");
+        return;
+    }
+    const permission = await database_1.prisma.permissions.findUnique({
+        where: { id: BigInt(permissionId) },
+    });
+    if (!permission) {
+        (0, response_1.sendError)(res, 404, "Permission not found");
+        return;
+    }
+    await database_1.prisma.user_permissions.upsert({
+        where: {
+            user_id_permission_id: {
+                user_id: BigInt(userId),
+                permission_id: BigInt(permissionId),
+            },
+        },
+        create: {
+            user_id: BigInt(userId),
+            permission_id: BigInt(permissionId),
+            created_at: new Date(),
+        },
+        update: {},
+    });
+    (0, response_1.sendFastSuccess)(res, 200, voidSerializer, {
+        status: "success",
+        message: "Permission assigned to user",
+        data: null,
+    });
+}
+async function removePermissionFromUser(req, res) {
+    const validator = validator_1.Validator.make(req.body || {}, {
+        userId: zod_1.z.string().min(1, "userId wajib diisi"),
+        permissionId: zod_1.z.string().min(1, "permissionId wajib diisi"),
+    });
+    if (await validator.fails()) {
+        (0, response_1.sendError)(res, 422, "Validation error", validator.errors());
+        return;
+    }
+    const { userId, permissionId } = await validator.validated();
+    await database_1.prisma.user_permissions.deleteMany({
+        where: {
+            user_id: BigInt(userId),
+            permission_id: BigInt(permissionId),
+        },
+    });
+    (0, response_1.sendFastSuccess)(res, 200, voidSerializer, {
+        status: "success",
+        message: "Permission removed from user",
+        data: null,
+    });
+}

package/dist/src/core/database.d.ts

@@ -0,0 +1,3 @@
+declare let prisma: any;
+export { prisma };
+//# sourceMappingURL=database.d.ts.map

package/dist/src/core/database.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"database.d.ts","sourceRoot":"","sources":["../../../src/core/database.ts"],"names":[],"mappings":"AAOA,QAAA,IAAI,MAAM,EAAE,GAAG,CAAC;AAyBhB,OAAO,EAAE,MAAM,EAAE,CAAC"}

package/dist/src/core/database.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prisma = void 0;
+const { PrismaClient } = require("@prisma/client");
+const adapter_pg_1 = require("@prisma/adapter-pg");
+const adapter_mariadb_1 = require("@prisma/adapter-mariadb");
+const url = process.env.DATABASE_URL || "";
+const provider = (process.env.DATABASE_PROVIDER || "").toLowerCase();
+let prisma;
+if (provider === "postgresql" || url.startsWith("postgres")) {
+    const adapter = new adapter_pg_1.PrismaPg({ connectionString: url });
+    exports.prisma = prisma = new PrismaClient({ adapter });
+}
+else {
+    if (provider === "mysql" || url.startsWith("mysql")) {
+        try {
+            const u = new URL(url);
+            const adapter = new adapter_mariadb_1.PrismaMariaDb({
+                host: u.hostname,
+                port: Number(u.port || "3306"),
+                user: decodeURIComponent(u.username),
+                password: decodeURIComponent(u.password),
+                database: u.pathname.replace("/", ""),
+            });
+            exports.prisma = prisma = new PrismaClient({ adapter });
+        }
+        catch {
+            exports.prisma = prisma = new PrismaClient({});
+        }
+    }
+    else {
+        exports.prisma = prisma = new PrismaClient({});
+    }
+}

package/dist/src/core/realtime.d.ts

@@ -0,0 +1,3 @@
+export declare function initRealtime(server: import("http").Server): void;
+export declare function notifyUser(userId: string, event: string, payload: any): void;
+//# sourceMappingURL=realtime.d.ts.map

package/dist/src/core/realtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"realtime.d.ts","sourceRoot":"","sources":["../../../src/core/realtime.ts"],"names":[],"mappings":"AAKA,wBAAgB,YAAY,CAAC,MAAM,EAAE,OAAO,MAAM,EAAE,MAAM,QAuBzD;AAED,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,QAGrE"}

package/dist/src/core/realtime.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initRealtime = initRealtime;
+exports.notifyUser = notifyUser;
+const socket_io_1 = require("socket.io");
+const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+let io = null;
+function initRealtime(server) {
+    io = new socket_io_1.Server(server, {
+        cors: { origin: "*", methods: ["GET", "POST", "PUT", "DELETE"] },
+    });
+    io.on("connection", (socket) => {
+        const token = socket.handshake.query?.token ||
+            socket.handshake.headers["authorization"]
+                ?.toString()
+                ?.replace("Bearer ", "") ||
+            "";
+        const secret = process.env.JWT_SECRET;
+        if (secret && token) {
+            try {
+                const payload = jsonwebtoken_1.default.verify(token, secret);
+                const room = `user:${payload.userId}`;
+                socket.join(room);
+            }
+            catch { }
+        }
+    });
+}
+function notifyUser(userId, event, payload) {
+    if (!io)
+        return;
+    io.to(`user:${userId}`).emit(event, payload);
+}

package/dist/src/core/redis.d.ts

@@ -0,0 +1,8 @@
+import Redis from "ioredis";
+export declare function initRedis(): Promise<void>;
+declare const redisProxy: Redis;
+export declare function getCache(key: string): Promise<any>;
+export declare function setCache(key: string, value: any, ttlSeconds?: number): Promise<void>;
+export declare function delCache(key: string): Promise<void>;
+export { redisProxy as redis };
+//# sourceMappingURL=redis.d.ts.map

package/dist/src/core/redis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis.d.ts","sourceRoot":"","sources":["../../../src/core/redis.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,SAAS,CAAC;AA4D5B,wBAAsB,SAAS,kBAoC9B;AAGD,QAAA,MAAM,UAAU,OAMd,CAAC;AAEH,wBAAsB,QAAQ,CAAC,GAAG,EAAE,MAAM,gBAOzC;AAED,wBAAsB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,EAAE,UAAU,SAAK,iBAItE;AAED,wBAAsB,QAAQ,CAAC,GAAG,EAAE,MAAM,iBAIzC;AAGD,OAAO,EAAE,UAAU,IAAI,KAAK,EAAE,CAAC"}

package/dist/src/core/redis.js

@@ -0,0 +1,123 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.redis = void 0;
+exports.initRedis = initRedis;
+exports.getCache = getCache;
+exports.setCache = setCache;
+exports.delCache = delCache;
+const ioredis_1 = __importDefault(require("ioredis"));
+// @ts-ignore
+const ioredis_mock_1 = __importDefault(require("ioredis-mock"));
+const redisUrl = process.env.REDIS_URL || "redis://localhost:6379";
+// Create a wrapper to handle connection attempts
+let redis;
+let isRedisConnected = false;
+// If explicitly disabled via env
+if (process.env.NO_REDIS === "true") {
+    console.log("Redis disabled via NO_REDIS, using in-memory mock.");
+    redis = new ioredis_mock_1.default();
+    isRedisConnected = true;
+}
+else {
+    // Try to connect to real Redis
+    redis = new ioredis_1.default(redisUrl, {
+        lazyConnect: true,
+        maxRetriesPerRequest: 1,
+        retryStrategy: (times) => {
+            // Retry 3 times then give up
+            if (times > 3)
+                return null;
+            return 200;
+        },
+    });
+}
+redis.on("ready", () => {
+    isRedisConnected = true;
+    // console.log("Redis connected!");
+});
+redis.on("error", (_err) => {
+    // If connection fails and we haven't switched to mock yet
+    if (!isRedisConnected && !(redis instanceof ioredis_mock_1.default)) {
+        // console.log("Redis connection failed, switching to in-memory mock...");
+        // Replace the global redis instance with mock
+        // Note: This is a runtime switch. Existing listeners might be lost if we don't handle carefully.
+        // However, for a simple fallback, we can just use the mock for future calls.
+        // Better approach: Since we exported 'redis' as a const (reference), we can't reassign it easily
+        // if other modules already imported it.
+        // BUT, ioredis instance itself is an EventEmitter.
+        // Strategy: We keep 'redis' as the main interface.
+        // If real redis fails, we just don't set isRedisConnected to true for the *real* one.
+        // But wait, the user wants 'bundle redis'.
+        // The best way is to detect failure during init and SWAP the implementation.
+    }
+    isRedisConnected = false;
+});
+// We need a way to seamlessly switch or just default to Mock if connect fails.
+// Since 'redis' is exported immediately, we can't easily swap the object reference for importers.
+// PROXY APPROACH:
+// We export a Proxy that forwards to real redis OR mock redis.
+const mockRedis = new ioredis_mock_1.default();
+let activeRedis = redis; // Start with real redis attempt
+// Custom init function to determine which one to use
+async function initRedis() {
+    if (process.env.NO_REDIS === "true") {
+        activeRedis = mockRedis;
+        console.log("✅ Redis: Active (Source: Zero-Config Redis [NO_REDIS=true])");
+        if (process.env.NODE_ENV === "production") {
+            console.warn("⚠️  WARNING: Running in PRODUCTION with in-memory Redis mock. Data will be lost on restart and not shared between instances.");
+        }
+        return;
+    }
+    try {
+        await redis.connect();
+        activeRedis = redis; // Keep using real redis
+        isRedisConnected = true;
+        // Determine source label
+        const sourceLabel = process.env.REDIS_URL
+            ? redisUrl
+            : "Zero-Config Redis (Localhost)";
+        console.log(`✅ Redis: Active (Source: ${sourceLabel})`);
+    }
+    catch (err) {
+        // Connection failed, switch to mock
+        console.log(`⚠️  Redis: Connection failed to ${redisUrl}, switching to fallback (Source: Zero-Config Redis [Mock])`);
+        activeRedis = mockRedis;
+        isRedisConnected = true; // Mock is always "connected"
+        if (process.env.NODE_ENV === "production") {
+            console.warn("⚠️  WARNING: Redis connection failed in PRODUCTION. Switched to in-memory mock. Data will be lost on restart.");
+        }
+    }
+}
+// Proxy handler to forward all calls to activeRedis
+const redisProxy = new Proxy({}, {
+    get: (_target, prop) => {
+        // If accessing a property on the proxy, forward it to activeRedis
+        const value = activeRedis[prop];
+        return value;
+    },
+});
+exports.redis = redisProxy;
+async function getCache(key) {
+    try {
+        const v = await activeRedis.get(key);
+        return v ? JSON.parse(v) : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function setCache(key, value, ttlSeconds = 60) {
+    try {
+        await activeRedis.set(key, JSON.stringify(value), "EX", ttlSeconds);
+    }
+    catch { }
+}
+async function delCache(key) {
+    try {
+        await activeRedis.del(key);
+    }
+    catch { }
+}