@raclettejs/core 0.0.1

package/services/backend/dist/src/domains/system/routes/route.user.checkToken.js

@@ -0,0 +1,40 @@
+import { authenticate } from "../../../modules/authentication/index.js";
+import { callDataTypeOperation } from "../../../core/contracting/contractRegistrar.js";
+export default (fastify) => {
+    const checkDatabase = async () => {
+        const userCount = await callDataTypeOperation("raclette__core", "user", "readCount");
+        return userCount > 0;
+    };
+    const handler = async (req, reply) => {
+        if (!(await checkDatabase())) {
+            // user database is empty
+            // this is a critical information for the frontend
+            const replyObj = {
+                statusCode: 500,
+                code: "RCLT_DB_NO_USERS",
+                error: "NoUsersInDatabase",
+                message: "No Users in Database",
+            };
+            return reply.code(replyObj.statusCode).send(replyObj);
+        }
+        try {
+            await authenticate(req, reply, fastify);
+        }
+        catch (error) {
+            console.error(error);
+        }
+        return reply.send(req.user);
+    };
+    return {
+        handler: handler,
+        skipHeaderValidation: true,
+        schema: {
+            summary: "Get a single user.",
+            description: `Retrieve a single user, e.g. to edit the object. Only
+    administrators, project maintainers and the user himself/herself can access
+    this object directly.`,
+            tags: ["core/user"],
+            params: {},
+        },
+    };
+};

package/services/backend/dist/src/domains/system/routes/route.user.login.d.ts

@@ -0,0 +1,44 @@
+import type { Static } from "@sinclair/typebox";
+import type { FastifyRequest, FastifyReply, FastifyInstance } from "fastify";
+declare const LoginBodySchema: import("@sinclair/typebox").TObject<{
+    email: import("@sinclair/typebox").TString;
+    password: import("@sinclair/typebox").TString;
+    deviceId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>;
+type LoginBody = Static<typeof LoginBodySchema>;
+declare const _default: (fastify: FastifyInstance) => {
+    handler: (request: FastifyRequest<{
+        Body: LoginBody;
+    }>, reply: FastifyReply) => Promise<{
+        token: string;
+        decoded: import("@fastify/jwt").DecodePayloadType;
+        user: import("../../../corePlugins/raclette__core/server/datatypes/user/user.schema.js").PublicUser;
+        requestId: string;
+    }>;
+    preValidation: (request: FastifyRequest<{
+        Body: LoginBody;
+    }>, _reply: FastifyReply, done: (error?: Error) => void) => void;
+    schema: {
+        summary: string;
+        description: string;
+        tags: string[];
+        body: import("@sinclair/typebox").TObject<{
+            email: import("@sinclair/typebox").TString;
+            password: import("@sinclair/typebox").TString;
+            deviceId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        }>;
+        response: {
+            200: import("@sinclair/typebox").TObject<{
+                token: import("@sinclair/typebox").TString;
+                decoded: import("@sinclair/typebox").TAny;
+                user: import("@sinclair/typebox").TAny;
+                requestId: import("@sinclair/typebox").TString;
+            }>;
+            429: import("@sinclair/typebox").TObject<{
+                error: import("@sinclair/typebox").TString;
+                lockTimeRemaining: import("@sinclair/typebox").TNumber;
+            }>;
+        };
+    };
+};
+export default _default;

package/services/backend/dist/src/domains/system/routes/route.user.login.js

@@ -0,0 +1,163 @@
+import { Type } from "@sinclair/typebox";
+import { toPublicUser } from "../../../corePlugins/raclette__core/server/datatypes/user/user.schema.js";
+import { randomIdGenerator } from "../../../helpers/index.js";
+import { ForbiddenError, NotFoundError, UnauthorizedError, UserError, } from "../../../utils/errors.js";
+import { REDIS_CONFIG } from "../../../modules/cache/providers/redis/redisConfig.js";
+import { callDataTypeOperation } from "../../../core/contracting/contractRegistrar.js";
+const { LOGIN_ATTEMPTS, KEY_PREFIXES } = REDIS_CONFIG;
+const LoginBodySchema = Type.Object({
+    email: Type.String(),
+    password: Type.String(),
+    deviceId: Type.Optional(Type.String()),
+});
+const ResponseSchema = Type.Object({
+    token: Type.String(),
+    decoded: Type.Any(),
+    user: Type.Any(),
+    requestId: Type.String(),
+});
+const randomId = randomIdGenerator(16);
+export default (fastify) => {
+    const trackLoginAttempt = async (key) => {
+        const attemptsKey = `${KEY_PREFIXES.LOGIN_ATTEMPTS}${key}`;
+        const multi = fastify.redis.multi();
+        multi.incr(attemptsKey);
+        multi.expire(attemptsKey, LOGIN_ATTEMPTS.ATTEMPT_WINDOW);
+        const results = await multi.exec();
+        const attempts = results?.[0]?.[1];
+        if (attempts >= LOGIN_ATTEMPTS.MAX_ATTEMPTS) {
+            const lockKey = `${KEY_PREFIXES.LOGIN_LOCK}${key}`;
+            await fastify.redis.setex(lockKey, LOGIN_ATTEMPTS.LOCKOUT_DURATION, "1");
+        }
+    };
+    const canAttemptLogin = async (key) => {
+        const lockKey = `${KEY_PREFIXES.LOGIN_LOCK}${key}`;
+        const attemptsKey = `${KEY_PREFIXES.LOGIN_ATTEMPTS}${key}`;
+        const [isLocked, attempts] = await Promise.all([
+            fastify.redis.exists(lockKey),
+            fastify.redis.get(attemptsKey),
+        ]);
+        if (isLocked) {
+            fastify.log.info(`Login blocked for ${key}: Account is locked`);
+            return false;
+        }
+        const attemptCount = attempts ? parseInt(attempts) : 0;
+        const canAttempt = attemptCount < LOGIN_ATTEMPTS.MAX_ATTEMPTS;
+        if (!canAttempt) {
+            fastify.log.info(`Login blocked for ${key}: Too many attempts (${attemptCount})`);
+        }
+        return canAttempt;
+    };
+    const resetLoginAttempts = async (key) => {
+        const lockKey = `${KEY_PREFIXES.LOGIN_LOCK}${key}`;
+        const attemptsKey = `${KEY_PREFIXES.LOGIN_ATTEMPTS}${key}`;
+        await Promise.all([
+            fastify.redis.del(attemptsKey),
+            fastify.redis.del(lockKey),
+        ]);
+    };
+    const readUser = async (email, password) => {
+        const user = await callDataTypeOperation("raclette__core", "user", "readByMail", email);
+        if (!user) {
+            throw new NotFoundError("User not found");
+        }
+        if (user.blocked) {
+            throw new ForbiddenError("User is blocked");
+        }
+        if (!user.email_verified) {
+            throw new UnauthorizedError("Email not verified");
+        }
+        if (!user.active) {
+            throw new ForbiddenError("User account is inactive");
+        }
+        const isCorrectPassword = await user.checkPassword(password);
+        if (!isCorrectPassword) {
+            throw new UnauthorizedError("Invalid credentials");
+        }
+        return user;
+    };
+    const checkDatabase = async () => {
+        const userCount = await callDataTypeOperation("raclette__core", "user", "readCount");
+        return userCount > 0;
+    };
+    const handler = async (request, reply) => {
+        const { email, password, deviceId } = request.body;
+        const clientKey = deviceId || request.ip || email.toLowerCase();
+        if (!(await checkDatabase())) {
+            // user database is empty
+            // this is a critical information for the frontend
+            const replyObj = {
+                statusCode: 500,
+                code: "RCLT_DB_NO_USERS",
+                error: "NoUsersInDatabase",
+                message: "No Users in Database",
+            };
+            return reply.code(replyObj.statusCode).send(replyObj);
+        }
+        try {
+            if (!(await canAttemptLogin(clientKey))) {
+                const remainingLockTime = await fastify.redis.ttl(`${KEY_PREFIXES.LOGIN_LOCK}${clientKey}`);
+                return reply.code(429).send({
+                    error: "Too many login attempts. Please try again later.",
+                    lockTimeRemaining: remainingLockTime,
+                });
+            }
+            console.warn("TRACK LOGIN ATTEMPT");
+            await trackLoginAttempt(clientKey);
+            const user = await readUser(email, password);
+            // Reset login attempts on successful login
+            await resetLoginAttempts(clientKey);
+            // Create token with additional security measures
+            const tokenPayload = {
+                _id: user._id.split("|").pop(),
+                tokenId: randomId,
+                deviceId: deviceId || request.ip,
+                iat: Math.floor(Date.now() / 1000),
+            };
+            const token = fastify.jwt.sign(tokenPayload, {
+                expiresIn: "24h",
+            });
+            const decoded = fastify.jwt.decode(token);
+            fastify.log.info(`Successful login for user ${user._id}`);
+            return {
+                token,
+                decoded,
+                user: toPublicUser(user),
+                requestId: request.id,
+            };
+        }
+        catch (error) {
+            fastify.log.error(`Login failed: ${error.message}`);
+            if (error instanceof UserError) {
+                return reply.code(error.statusCode).send({ error: error.message });
+            }
+            return reply.code(500).send({ error: "Authentication failed" });
+        }
+    };
+    return {
+        handler,
+        preValidation: (request, _reply, done) => {
+            if (request.body?.email) {
+                request.body.email = request.body.email.toLowerCase().trim();
+            }
+            done();
+        },
+        schema: {
+            summary: "Authenticate user and receive access token",
+            description: `Secure login endpoint with rate limiting and brute force protection.
+        Implements Redis-based attempt tracking and temporary lockouts.
+        Max attempts: ${LOGIN_ATTEMPTS.MAX_ATTEMPTS}
+        Lockout duration: ${LOGIN_ATTEMPTS.LOCKOUT_DURATION} seconds
+        Attempt window: ${LOGIN_ATTEMPTS.ATTEMPT_WINDOW} seconds`,
+            tags: ["core/user"],
+            body: LoginBodySchema,
+            response: {
+                200: ResponseSchema,
+                429: Type.Object({
+                    error: Type.String(),
+                    lockTimeRemaining: Type.Number(),
+                }),
+            },
+        },
+    };
+};

package/services/backend/dist/src/helpers/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Random ID generator
+ *
+ * @param length - Required length for the output
+ * @returns Function that generates random IDs
+ * @example
+ * const generateId = randomIdGenerator(12);
+ * const id = generateId(); // => 'gdh6326GDJh0'
+ */
+declare const randomIdGenerator: (length?: number) => (() => string);
+export { randomIdGenerator };

package/services/backend/dist/src/helpers/index.js

@@ -0,0 +1,13 @@
+import { customAlphabet } from "nanoid";
+const customCyperAlphabet = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+/**
+ * Random ID generator
+ *
+ * @param length - Required length for the output
+ * @returns Function that generates random IDs
+ * @example
+ * const generateId = randomIdGenerator(12);
+ * const id = generateId(); // => 'gdh6326GDJh0'
+ */
+const randomIdGenerator = (length = 16) => customAlphabet(customCyperAlphabet, length);
+export { randomIdGenerator };

package/services/backend/dist/src/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./types/index.js";
+export * from "./utils/index.js";
+export * from "./core/contracting/contractRegistrar.js";

package/services/backend/dist/src/index.js

@@ -0,0 +1,3 @@
+export * from "./types/index.js";
+export * from "./utils/index.js";
+export * from "./core/contracting/contractRegistrar.js";

package/services/backend/dist/src/modules/authentication/index.d.ts

@@ -0,0 +1,4 @@
+import type { FastifyRequest, FastifyReply, FastifyInstance } from "fastify";
+export declare const authenticate: (req: FastifyRequest, res: FastifyReply, fastify: FastifyInstance) => Promise<never>;
+declare const _default: (fastify: FastifyInstance, opts?: Record<never, never>) => Promise<void>;
+export default _default;

package/services/backend/dist/src/modules/authentication/index.js

@@ -0,0 +1,80 @@
+import jwt from "@fastify/jwt";
+import fastifyPlugin from "fastify-plugin";
+import configService from "../../core/config/configService.js";
+export const authenticate = async (req, res, fastify) => {
+    {
+        const { requireAuthentication } = configService.getConfig()?.global ?? {
+            requireAuthentication: true,
+        };
+        const isAdminTagRequired = configService.isAdminTagRequired();
+        // Skip JWT verification and database queries, if global.requireAuthentication is configured to false
+        if (!requireAuthentication) {
+            const mockUser = {
+                _id: "SYSTEM",
+            };
+            req.user = mockUser;
+            return;
+        }
+        try {
+            await req.jwtVerify();
+            // fetch current user data from the db
+            const { _id } = req.user;
+            const adminTag = await fastify.database
+                .collection("raclette__core-tag")
+                .findOne({ title: "ADMIN", locked: true, type: "system" });
+            // IMPORTANT
+            // due to some very weird behaviour, mongoose always returns empty results
+            // so we are using mongodb directly until we fix this
+            let isAdmin = false;
+            const user = await fastify.database
+                .collection("raclette__core-user")
+                .findOne({ _id }, { projection: { password: 0, resetKey: 0 } });
+            if (user.tags && adminTag) {
+                user.tags.forEach((tag) => {
+                    if (adminTag._id === tag) {
+                        isAdmin = true;
+                    }
+                });
+            }
+            if (isAdminTagRequired && !isAdmin) {
+                fastify.log.error("User not allowed in workbench");
+                throw new Error("User not allowed in workbench");
+            }
+            if (isAdmin) {
+                user.isAdmin = true;
+            }
+            if (!user) {
+                fastify.log.error("User not found");
+                throw new Error("User not found");
+            }
+            const account = await fastify.database
+                .collection("raclette__core-account")
+                .findOne({ _id: user.account });
+            user.account = account;
+            req.user = user;
+        }
+        catch (error) {
+            return res.send(error);
+        }
+    }
+};
+export default fastifyPlugin(async (fastify, opts = {}) => {
+    // provide some sensible options
+    const defaults = {
+        secret: false,
+        decode: { complete: true },
+        sign: {
+            iss: "api.projectjournal.pacifico.info",
+            expiresIn: "30d",
+        },
+        verify: { allowedIss: "api.projectjournal.pacifico.info" },
+    };
+    // merge proved opts with defaults
+    const mergedOptions = { ...defaults, ...opts };
+    /* register the plugin */
+    fastify.register(jwt, mergedOptions);
+    // decorate the fastify instance, so we can call it anywhere
+    fastify.decorate("authenticate", (req, res) => {
+        return authenticate(req, res, fastify);
+    });
+});

package/services/backend/dist/src/modules/cache/cacheManager.d.ts

@@ -0,0 +1,6 @@
+import type { CacheOptions, CacheService } from "../../types/index.js";
+import type { RedisService } from "../../modules/cache/providers/redis/redisTypes.js";
+/**
+ * Creates a cache service with the given options
+ */
+export declare const createCacheService: (redis: RedisService, options?: CacheOptions) => CacheService;

package/services/backend/dist/src/modules/cache/cacheManager.js

@@ -0,0 +1,131 @@
+/**
+ * Creates a cache service with the given options
+ */
+export const createCacheService = (redis, options = {}) => {
+    const prefix = options.prefix ? `${options.prefix}:` : "cache:";
+    const defaultTtl = options.defaultTtl;
+    const buildKey = (key) => `${prefix}${key}`;
+    const service = {
+        cache: async (key, data, options = {}) => {
+            const fullKey = buildKey(key);
+            // Default serialization/deserialization uses JSON
+            const serialize = options.serialize || JSON.stringify;
+            const serializedNewData = serialize(data);
+            // Get previously cached data
+            const previousData = await redis.get(fullKey);
+            // Determine if data has changed
+            const hasChanged = previousData === null || previousData !== serializedNewData;
+            // Cache the new data if it changed or doesn't exist
+            if (hasChanged) {
+                const ttl = options.ttl ?? defaultTtl;
+                if (ttl) {
+                    await redis.setex(fullKey, ttl, serializedNewData);
+                }
+                else {
+                    await redis.set(fullKey, serializedNewData);
+                }
+            }
+            return {
+                changed: hasChanged,
+                data: data,
+            };
+        },
+        get: async (key, deserialize = JSON.parse) => {
+            const fullKey = buildKey(key);
+            const data = await redis.get(fullKey);
+            if (data === null) {
+                return null;
+            }
+            return deserialize(data);
+        },
+        forceUpdate: async (key, data, options = {}) => {
+            const fullKey = buildKey(key);
+            const serialized = JSON.stringify(data);
+            const ttl = options.ttl ?? defaultTtl;
+            if (ttl) {
+                await redis.setex(fullKey, ttl, serialized);
+            }
+            else {
+                await redis.set(fullKey, serialized);
+            }
+            return data;
+        },
+        invalidate: async (key) => {
+            const fullKey = buildKey(key);
+            await redis.del(fullKey);
+        },
+        invalidatePattern: async (pattern) => {
+            const fullPattern = buildKey(pattern);
+            const keys = await redis.keys(fullPattern);
+            if (keys.length > 0) {
+                await redis.del(...keys);
+            }
+            return keys.length;
+        },
+        // Get all keys matching a pattern (within this service's namespace)
+        getKeysByPattern: async (pattern) => {
+            const fullPattern = buildKey(pattern);
+            const keys = await redis.keys(fullPattern);
+            // Strip the prefix to return clean keys to the caller
+            return keys.map((key) => key.replace(prefix, ""));
+        },
+        // Get TTL for a specific key
+        getTtl: async (key) => {
+            const fullKey = buildKey(key);
+            return await redis.ttl(fullKey);
+        },
+        // Get multiple keys with their metadata
+        getKeysWithMetadata: async (pattern) => {
+            const fullPattern = buildKey(pattern);
+            const keys = await redis.keys(fullPattern);
+            const metadata = await Promise.all(keys.map(async (fullKey) => {
+                const cleanKey = fullKey.replace(prefix, "");
+                const ttl = await redis.ttl(fullKey);
+                return {
+                    key: cleanKey,
+                    ttl,
+                    exists: true,
+                };
+            }));
+            return metadata;
+        },
+        // Invalidate multiple specific keys atomically
+        invalidateMultiple: async (keys) => {
+            if (keys.length === 0)
+                return 0;
+            const fullKeys = keys.map((key) => buildKey(key));
+            await redis.del(...fullKeys);
+            return keys.length;
+        },
+        // Check if a key exists
+        exists: async (key) => {
+            const fullKey = buildKey(key);
+            const result = await redis.exists(fullKey);
+            return result === 1;
+        },
+        // Get key information (value + metadata)
+        getWithMetadata: async (key, deserialize = JSON.parse) => {
+            const fullKey = buildKey(key);
+            const [value, ttl, exists] = await Promise.all([
+                redis.get(fullKey),
+                redis.ttl(fullKey),
+                redis.exists(fullKey),
+            ]);
+            return {
+                value: value ? deserialize(value) : null,
+                ttl,
+                exists: exists === 1,
+            };
+        },
+        namespace: (namespace, namespaceOptions = {}) => {
+            const newPrefix = namespaceOptions.prefix || `${prefix}${namespace}:`;
+            const newOptions = {
+                ...options,
+                ...namespaceOptions,
+                prefix: newPrefix,
+            };
+            return createCacheService(redis, newOptions);
+        },
+    };
+    return service;
+};

package/services/backend/dist/src/modules/cache/cacheTypes.d.ts

@@ -0,0 +1,102 @@
+export type CacheOptions = {
+    prefix?: string;
+    defaultTtl?: number;
+};
+export type CacheResult<T> = {
+    changed: boolean;
+    data: T;
+};
+export type CacheKeyMetadata = {
+    key: string;
+    ttl: number;
+    exists: boolean;
+};
+export type CacheValueWithMetadata<T> = {
+    value: T | null;
+    ttl: number;
+    exists: boolean;
+};
+export type CacheService = {
+    /**
+     * Caches data and returns whether it has changed
+     * @param key The cache key
+     * @param data The data to cache
+     * @param options Additional options
+     * @returns An object containing whether the data has changed and the cached data
+     */
+    cache<T>(key: string, data: T, options?: {
+        ttl?: number;
+        serialize?: (data: T) => string;
+        deserialize?: (data: string) => T;
+    }): Promise<CacheResult<T>>;
+    /**
+     * Retrieve data from cache
+     * @param key The cache key
+     * @param deserialize Function to deserialize the data (defaults to JSON.parse)
+     * @returns The cached data or null if not found
+     */
+    get<T>(key: string, deserialize?: (data: string) => T): Promise<T | null>;
+    /**
+     * Replaces the entry with the given new data
+     * @param key The cache key
+     * @param data New data that will replace the old one
+     * @param options Additional options
+     */
+    forceUpdate<T>(key: string, data: T, options?: {
+        ttl?: number;
+    }): Promise<T>;
+    /**
+     * Remove data from cache
+     * @param key The cache key
+     */
+    invalidate(key: string): Promise<void>;
+    /**
+     * Remove all cache entries matching a pattern
+     * @param pattern The key pattern to match (e.g., "user:*")
+     * @returns The number of keys that were deleted
+     */
+    invalidatePattern(pattern: string): Promise<number>;
+    /**
+     * Get all keys matching a pattern (within this service's namespace)
+     * @param pattern The key pattern to match (e.g., "user:*")
+     * @returns Array of matching keys (without the service prefix)
+     */
+    getKeysByPattern(pattern: string): Promise<string[]>;
+    /**
+     * Get the TTL (time to live) for a specific key
+     * @param key The cache key
+     * @returns TTL in seconds (-1 if no expiry, -2 if key doesn't exist)
+     */
+    getTtl(key: string): Promise<number>;
+    /**
+     * Get multiple keys with their metadata
+     * @param pattern The key pattern to match
+     * @returns Array of objects containing key, ttl, and exists status
+     */
+    getKeysWithMetadata(pattern: string): Promise<CacheKeyMetadata[]>;
+    /**
+     * Remove multiple specific keys atomically
+     * @param keys Array of cache keys to remove
+     * @returns The number of keys that were deleted
+     */
+    invalidateMultiple(keys: string[]): Promise<number>;
+    /**
+     * Check if a key exists in the cache
+     * @param key The cache key
+     * @returns True if the key exists, false otherwise
+     */
+    exists(key: string): Promise<boolean>;
+    /**
+     * Get cached value along with its metadata
+     * @param key The cache key
+     * @param deserialize Function to deserialize the data (defaults to JSON.parse)
+     * @returns Object containing value, TTL, and existence status
+     */
+    getWithMetadata<T>(key: string, deserialize?: (data: string) => T): Promise<CacheValueWithMetadata<T>>;
+    /**
+     * Create a namespaced cache service
+     * @param namespace The namespace for all cache keys
+     * @param options Additional options
+     */
+    namespace(namespace: string, options?: CacheOptions): CacheService;
+};

package/services/backend/dist/src/modules/cache/cacheTypes.js

@@ -0,0 +1 @@
+export {};

package/services/backend/dist/src/modules/cache/providers/redis/redisConfig.d.ts

@@ -0,0 +1,11 @@
+export declare const REDIS_CONFIG: {
+    readonly LOGIN_ATTEMPTS: {
+        readonly MAX_ATTEMPTS: number;
+        readonly LOCKOUT_DURATION: number;
+        readonly ATTEMPT_WINDOW: number;
+    };
+    readonly KEY_PREFIXES: {
+        readonly LOGIN_ATTEMPTS: "login_attempts:";
+        readonly LOGIN_LOCK: "login_lock:";
+    };
+};

package/services/backend/dist/src/modules/cache/providers/redis/redisConfig.js

@@ -0,0 +1,17 @@
+export const REDIS_CONFIG = {
+    LOGIN_ATTEMPTS: {
+        MAX_ATTEMPTS: process.env.LOGIN_MAX_ATTEMPTS
+            ? parseInt(process.env.LOGIN_MAX_ATTEMPTS)
+            : 5,
+        LOCKOUT_DURATION: process.env.LOGIN_LOCKOUT_DURATION
+            ? parseInt(process.env.LOGIN_LOCKOUT_DURATION)
+            : 15 * 60,
+        ATTEMPT_WINDOW: process.env.LOGIN_ATTEMPT_WINDOW
+            ? parseInt(process.env.LOGIN_ATTEMPT_WINDOW)
+            : 30 * 60,
+    },
+    KEY_PREFIXES: {
+        LOGIN_ATTEMPTS: "login_attempts:",
+        LOGIN_LOCK: "login_lock:",
+    },
+};

package/services/backend/dist/src/modules/cache/providers/redis/redisConnection.d.ts

@@ -0,0 +1,4 @@
+import type { FastifyInstance } from "fastify";
+import type { RedisPluginOptions } from "./redisTypes.js";
+declare const _default: (fastify: FastifyInstance, options: RedisPluginOptions, done: any) => void;
+export default _default;