@raclettejs/core 0.1.0 → 0.1.1

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

@@ -1,40 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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

@@ -1,163 +0,0 @@
-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

@@ -1,11 +0,0 @@
-/**
- * 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

@@ -1,13 +0,0 @@
-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

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

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

@@ -1,3 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,80 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,131 +0,0 @@
-/**
- * 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

@@ -1,102 +0,0 @@
-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

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

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

@@ -1,11 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

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