@directus/api 14.1.2 → 16.0.0

package/dist/flows.js

@@ -1,13 +1,13 @@
 import { Action } from '@directus/constants';
+import { useEnv } from '@directus/env';
+import { ForbiddenError } from '@directus/errors';
 import { applyOptionsData, getRedactedString, isValidJSON, parseJSON, toArray } from '@directus/utils';
 import { omit, pick } from 'lodash-es';
 import { get } from 'micromustache';
+import { useBus } from './bus/index.js';
 import getDatabase from './database/index.js';
 import emitter from './emitter.js';
-import env from './env.js';
-import { ForbiddenError } from '@directus/errors';
-import logger from './logger.js';
-import { getMessenger } from './messenger.js';
+import { useLogger } from './logger.js';
 import { ActivityService } from './services/activity.js';
 import { FlowsService } from './services/flows.js';
 import * as services from './services/index.js';
@@ -40,9 +40,11 @@ class FlowManager {
     reloadQueue;
     envs;
     constructor() {
+        const env = useEnv();
+        const logger = useLogger();
         this.reloadQueue = new JobQueue();
         this.envs = env['FLOWS_ENV_ALLOW_LIST'] ? pick(env, toArray(env['FLOWS_ENV_ALLOW_LIST'])) : {};
-        const messenger = getMessenger();
+        const messenger = useBus();
         messenger.subscribe('flows', (event) => {
             if (event['type'] === 'reload') {
                 this.reloadQueue.enqueue(async () => {
@@ -63,7 +65,7 @@ class FlowManager {
         }
     }
     async reload() {
-        const messenger = getMessenger();
+        const messenger = useBus();
         messenger.publish('flows', { type: 'reload' });
     }
     addOperation(id, operation) {
@@ -73,6 +75,7 @@ class FlowManager {
         this.operations.delete(id);
     }
     async runOperationFlow(id, data, context) {
+        const logger = useLogger();
         if (!(id in this.operationFlowHandlers)) {
             logger.warn(`Couldn't find operation triggered flow with id "${id}"`);
             return null;
@@ -81,6 +84,7 @@ class FlowManager {
         return handler(data, context);
     }
     async runWebhookFlow(id, data, context) {
+        const logger = useLogger();
         if (!(id in this.webhookFlowHandlers)) {
             logger.warn(`Couldn't find webhook or manual triggered flow with id "${id}"`);
             throw new ForbiddenError();
@@ -89,6 +93,7 @@ class FlowManager {
         return handler(data, context);
     }
     async load() {
+        const logger = useLogger();
         const flowsService = new FlowsService({ knex: getDatabase(), schema: await getSchema() });
         const flows = await flowsService.readByQuery({
             filter: { status: { _eq: 'active' } },
@@ -305,6 +310,7 @@ class FlowManager {
         return undefined;
     }
     async executeOperation(operation, keyedData, context = {}) {
+        const logger = useLogger();
         if (!this.operations.has(operation.type)) {
             logger.warn(`Couldn't find operation ${operation.type}`);
             return { successor: null, status: 'unknown', data: null, options: null };
@@ -314,7 +320,7 @@ class FlowManager {
         try {
             let result = await handler(options, {
                 services,
-                env,
+                env: useEnv(),
                 database: getDatabase(),
                 logger,
                 getSchema,

package/dist/logger.d.ts

@@ -1,8 +1,9 @@
 /// <reference types="qs" />
 import type { RequestHandler } from 'express';
-import { type LoggerOptions } from 'pino';
-export declare const httpLoggerOptions: LoggerOptions;
-declare const logger: import("pino").Logger<LoggerOptions & Record<string, any>>;
-export declare const httpLoggerEnvConfig: Record<string, any>;
-export declare const expressLogger: RequestHandler<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
-export default logger;
+import { type Logger } from 'pino';
+export declare const _cache: {
+    logger: Logger<never> | undefined;
+};
+export declare const useLogger: () => Logger<never>;
+export declare const createLogger: () => Logger<never>;
+export declare const createExpressLogger: () => RequestHandler<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;

package/dist/logger.js

@@ -1,111 +1,136 @@
+import { useEnv } from '@directus/env';
 import { REDACTED_TEXT, toArray } from '@directus/utils';
 import { merge } from 'lodash-es';
 import { URL } from 'node:url';
 import { pino } from 'pino';
 import { pinoHttp, stdSerializers } from 'pino-http';
-import env from './env.js';
 import { getConfigFromEnv } from './utils/get-config-from-env.js';
-const pinoOptions = {
-    level: env['LOG_LEVEL'] || 'info',
-    redact: {
-        paths: ['req.headers.authorization', 'req.headers.cookie'],
-        censor: REDACTED_TEXT,
-    },
-};
-export const httpLoggerOptions = {
-    level: env['LOG_LEVEL'] || 'info',
-    redact: {
-        paths: ['req.headers.authorization', 'req.headers.cookie'],
-        censor: REDACTED_TEXT,
-    },
+export const _cache = { logger: undefined };
+export const useLogger = () => {
+    if (_cache.logger) {
+        return _cache.logger;
+    }
+    _cache.logger = createLogger();
+    return _cache.logger;
 };
-if (env['LOG_STYLE'] !== 'raw') {
-    pinoOptions.transport = {
-        target: 'pino-pretty',
-        options: {
-            ignore: 'hostname,pid',
-            sync: true,
+export const createLogger = () => {
+    const env = useEnv();
+    const pinoOptions = {
+        level: env['LOG_LEVEL'] || 'info',
+        redact: {
+            paths: ['req.headers.authorization', 'req.headers.cookie'],
+            censor: REDACTED_TEXT,
         },
     };
-    httpLoggerOptions.transport = {
-        target: 'pino-http-print',
-        options: {
-            all: true,
-            translateTime: 'SYS:HH:MM:ss',
-            relativeUrl: true,
-            prettyOptions: {
+    if (env['LOG_STYLE'] !== 'raw') {
+        pinoOptions.transport = {
+            target: 'pino-pretty',
+            options: {
                 ignore: 'hostname,pid',
                 sync: true,
             },
+        };
+    }
+    const loggerEnvConfig = getConfigFromEnv('LOGGER_', 'LOGGER_HTTP');
+    // Expose custom log levels into formatter function
+    if (loggerEnvConfig['levels']) {
+        const customLogLevels = {};
+        for (const el of toArray(loggerEnvConfig['levels'])) {
+            const key_val = el.split(':');
+            customLogLevels[key_val[0].trim()] = key_val[1].trim();
+        }
+        pinoOptions.formatters = {
+            level(label, number) {
+                return {
+                    severity: customLogLevels[label] || 'info',
+                    level: number,
+                };
+            },
+        };
+        delete loggerEnvConfig['levels'];
+    }
+    return pino(merge(pinoOptions, loggerEnvConfig));
+};
+export const createExpressLogger = () => {
+    const env = useEnv();
+    const httpLoggerEnvConfig = getConfigFromEnv('LOGGER_HTTP', ['LOGGER_HTTP_LOGGER']);
+    const loggerEnvConfig = getConfigFromEnv('LOGGER_', 'LOGGER_HTTP');
+    const httpLoggerOptions = {
+        level: env['LOG_LEVEL'] || 'info',
+        redact: {
+            paths: ['req.headers.authorization', 'req.headers.cookie'],
+            censor: REDACTED_TEXT,
         },
     };
-}
-if (env['LOG_STYLE'] === 'raw') {
-    httpLoggerOptions.redact = {
-        paths: ['req.headers.authorization', 'req.headers.cookie', 'res.headers'],
-        censor: (value, pathParts) => {
-            const path = pathParts.join('.');
-            if (path === 'res.headers') {
-                if ('set-cookie' in value) {
-                    value['set-cookie'] = REDACTED_TEXT;
+    if (env['LOG_STYLE'] !== 'raw') {
+        httpLoggerOptions.transport = {
+            target: 'pino-http-print',
+            options: {
+                all: true,
+                translateTime: 'SYS:HH:MM:ss',
+                relativeUrl: true,
+                prettyOptions: {
+                    ignore: 'hostname,pid',
+                    sync: true,
+                },
+            },
+        };
+    }
+    if (env['LOG_STYLE'] === 'raw') {
+        httpLoggerOptions.redact = {
+            paths: ['req.headers.authorization', 'req.headers.cookie', 'res.headers'],
+            censor: (value, pathParts) => {
+                const path = pathParts.join('.');
+                if (path === 'res.headers') {
+                    if ('set-cookie' in value) {
+                        value['set-cookie'] = REDACTED_TEXT;
+                    }
+                    return value;
                 }
-                return value;
-            }
-            return REDACTED_TEXT;
-        },
-    };
-}
-const loggerEnvConfig = getConfigFromEnv('LOGGER_', 'LOGGER_HTTP');
-// Expose custom log levels into formatter function
-if (loggerEnvConfig['levels']) {
-    const customLogLevels = {};
-    for (const el of toArray(loggerEnvConfig['levels'])) {
-        const key_val = el.split(':');
-        customLogLevels[key_val[0].trim()] = key_val[1].trim();
+                return REDACTED_TEXT;
+            },
+        };
     }
-    pinoOptions.formatters = {
-        level(label, number) {
-            return {
-                severity: customLogLevels[label] || 'info',
-                level: number,
-            };
-        },
-    };
-    httpLoggerOptions.formatters = {
-        level(label, number) {
-            return {
-                severity: customLogLevels[label] || 'info',
-                level: number,
-            };
-        },
-    };
-    delete loggerEnvConfig['levels'];
-}
-const logger = pino(merge(pinoOptions, loggerEnvConfig));
-export const httpLoggerEnvConfig = getConfigFromEnv('LOGGER_HTTP', ['LOGGER_HTTP_LOGGER']);
-if (env['LOG_HTTP_IGNORE_PATHS']) {
-    const ignorePathsSet = new Set(env['LOG_HTTP_IGNORE_PATHS']);
-    httpLoggerEnvConfig['autoLogging'] = {
-        ignore: (req) => {
-            if (!req.url)
-                return false;
-            const { pathname } = new URL(req.url, 'http://example.com/');
-            return ignorePathsSet.has(pathname);
-        },
-    };
-}
-export const expressLogger = pinoHttp({
-    logger: pino(merge(httpLoggerOptions, loggerEnvConfig)),
-    ...httpLoggerEnvConfig,
-    serializers: {
-        req(request) {
-            const output = stdSerializers.req(request);
-            output.url = redactQuery(output.url);
-            return output;
+    // Expose custom log levels into formatter function
+    if (loggerEnvConfig['levels']) {
+        const customLogLevels = {};
+        for (const el of toArray(loggerEnvConfig['levels'])) {
+            const key_val = el.split(':');
+            customLogLevels[key_val[0].trim()] = key_val[1].trim();
+        }
+        httpLoggerOptions.formatters = {
+            level(label, number) {
+                return {
+                    severity: customLogLevels[label] || 'info',
+                    level: number,
+                };
+            },
+        };
+        delete loggerEnvConfig['levels'];
+    }
+    if (env['LOG_HTTP_IGNORE_PATHS']) {
+        const ignorePathsSet = new Set(env['LOG_HTTP_IGNORE_PATHS']);
+        httpLoggerEnvConfig['autoLogging'] = {
+            ignore: (req) => {
+                if (!req.url)
+                    return false;
+                const { pathname } = new URL(req.url, 'http://example.com/');
+                return ignorePathsSet.has(pathname);
+            },
+        };
+    }
+    return pinoHttp({
+        logger: pino(merge(httpLoggerOptions, loggerEnvConfig)),
+        ...httpLoggerEnvConfig,
+        serializers: {
+            req(request) {
+                const output = stdSerializers.req(request);
+                output.url = redactQuery(output.url);
+                return output;
+            },
         },
-    },
-});
-export default logger;
+    });
+};
 function redactQuery(originalPath) {
     const url = new URL(originalPath, 'http://example.com/');
     if (url.searchParams.has('access_token')) {

package/dist/mailer.js

@@ -1,6 +1,6 @@
+import { useEnv } from '@directus/env';
 import nodemailer from 'nodemailer';
-import env from './env.js';
-import logger from './logger.js';
+import { useLogger } from './logger.js';
 import { getConfigFromEnv } from './utils/get-config-from-env.js';
 import { createRequire } from 'node:module';
 const require = createRequire(import.meta.url);
@@ -8,6 +8,8 @@ let transporter;
 export default function getMailer() {
     if (transporter)
         return transporter;
+    const env = useEnv();
+    const logger = useLogger();
     const transportName = env['EMAIL_TRANSPORT'].toLowerCase();
     if (transportName === 'sendmail') {
         transporter = nodemailer.createTransport({

package/dist/middleware/cache.js

@@ -1,12 +1,14 @@
+import { useEnv } from '@directus/env';
 import { getCache, getCacheValue } from '../cache.js';
-import env from '../env.js';
-import logger from '../logger.js';
+import { useLogger } from '../logger.js';
 import asyncHandler from '../utils/async-handler.js';
 import { getCacheControlHeader } from '../utils/get-cache-headers.js';
 import { getCacheKey } from '../utils/get-cache-key.js';
 import { shouldSkipCache } from '../utils/should-skip-cache.js';
 const checkCacheMiddleware = asyncHandler(async (req, res, next) => {
+    const env = useEnv();
     const { cache } = getCache();
+    const logger = useLogger();
     if (req.method.toLowerCase() !== 'get' && req.originalUrl?.startsWith('/graphql') === false)
         return next();
     if (env['CACHE_ENABLED'] !== true)

package/dist/middleware/check-ip.js

@@ -1,18 +1,37 @@
-import getDatabase from '../database/index.js';
 import { InvalidIpError } from '@directus/errors';
+import getDatabase from '../database/index.js';
+import { useLogger } from '../logger.js';
 import asyncHandler from '../utils/async-handler.js';
+import { ipInNetworks } from '../utils/ip-in-networks.js';
 export const checkIP = asyncHandler(async (req, _res, next) => {
     const database = getDatabase();
+    const logger = useLogger();
+    const { role: roleId, ip } = req.accountability;
     const query = database.select('ip_access').from('directus_roles');
-    if (req.accountability.role) {
-        query.where({ id: req.accountability.role });
+    if (roleId) {
+        query.where({ id: roleId });
     }
     else {
         query.whereNull('id');
     }
     const role = await query.first();
-    const ipAllowlist = (role?.ip_access || '').split(',').filter((ip) => ip);
-    if (ipAllowlist.length > 0 && ipAllowlist.includes(req.accountability.ip) === false)
-        throw new InvalidIpError();
+    if (!role?.ip_access)
+        return next();
+    const ipAllowList = role.ip_access.split(',').filter((ip) => ip);
+    if (ipAllowList.length > 0) {
+        if (!ip)
+            throw new InvalidIpError();
+        let allowed;
+        try {
+            allowed = ipInNetworks(ip, ipAllowList);
+        }
+        catch (error) {
+            logger.warn(`Invalid IP access configuration for role "${roleId}"`);
+            logger.warn(error);
+            throw new InvalidIpError();
+        }
+        if (!allowed)
+            throw new InvalidIpError();
+    }
     return next();
 });

package/dist/middleware/cors.js

@@ -1,6 +1,7 @@
+import { useEnv } from '@directus/env';
 import cors from 'cors';
-import env from '../env.js';
 let corsMiddleware = (_req, _res, next) => next();
+const env = useEnv();
 if (env['CORS_ENABLED'] === true) {
     corsMiddleware = cors({
         origin: env['CORS_ORIGIN'] || true,

package/dist/middleware/error-handler.js

@@ -1,20 +1,20 @@
-import { isDirectusError } from '@directus/errors';
+import { ErrorCode, MethodNotAllowedError, isDirectusError } from '@directus/errors';
 import { toArray } from '@directus/utils';
+import { getNodeEnv } from '@directus/utils/node';
 import getDatabase from '../database/index.js';
 import emitter from '../emitter.js';
-import env from '../env.js';
-import { ErrorCode, MethodNotAllowedError } from '@directus/errors';
-import logger from '../logger.js';
+import { useLogger } from '../logger.js';
 // Note: keep all 4 parameters here. That's how Express recognizes it's the error handler, even if
 // we don't use next
 const errorHandler = (err, req, res, _next) => {
+    const logger = useLogger();
     let payload = {
         errors: [],
     };
     const errors = toArray(err);
     let status = null;
     for (const err of errors) {
-        if (env['NODE_ENV'] === 'development') {
+        if (getNodeEnv() === 'development') {
             err.extensions = {
                 ...(err.extensions || {}),
                 stack: err.stack,

package/dist/middleware/rate-limiter-global.js

@@ -1,10 +1,12 @@
-import env from '../env.js';
+import { useEnv } from '@directus/env';
 import { HitRateLimitError } from '@directus/errors';
-import logger from '../logger.js';
+import { useLogger } from '../logger.js';
 import { createRateLimiter } from '../rate-limiter.js';
 import asyncHandler from '../utils/async-handler.js';
 import { validateEnv } from '../utils/validate-env.js';
 const RATE_LIMITER_GLOBAL_KEY = 'global-rate-limit';
+const env = useEnv();
+const logger = useLogger();
 let checkRateLimit = (_req, _res, next) => next();
 export let rateLimiterGlobal;
 if (env['RATE_LIMITER_GLOBAL_ENABLED'] === true) {

package/dist/middleware/rate-limiter-ip.js

@@ -1,4 +1,4 @@
-import env from '../env.js';
+import { useEnv } from '@directus/env';
 import { HitRateLimitError } from '@directus/errors';
 import { createRateLimiter } from '../rate-limiter.js';
 import asyncHandler from '../utils/async-handler.js';
@@ -6,21 +6,25 @@ import { getIPFromReq } from '../utils/get-ip-from-req.js';
 import { validateEnv } from '../utils/validate-env.js';
 let checkRateLimit = (_req, _res, next) => next();
 export let rateLimiter;
+const env = useEnv();
 if (env['RATE_LIMITER_ENABLED'] === true) {
     validateEnv(['RATE_LIMITER_STORE', 'RATE_LIMITER_DURATION', 'RATE_LIMITER_POINTS']);
     rateLimiter = createRateLimiter('RATE_LIMITER');
     checkRateLimit = asyncHandler(async (req, res, next) => {
-        try {
-            await rateLimiter.consume(getIPFromReq(req), 1);
-        }
-        catch (rateLimiterRes) {
-            if (rateLimiterRes instanceof Error)
-                throw rateLimiterRes;
-            res.set('Retry-After', String(Math.round(rateLimiterRes.msBeforeNext / 1000)));
-            throw new HitRateLimitError({
-                limit: +env['RATE_LIMITER_POINTS'],
-                reset: new Date(Date.now() + rateLimiterRes.msBeforeNext),
-            });
+        const ip = getIPFromReq(req);
+        if (ip) {
+            try {
+                await rateLimiter.consume(ip, 1);
+            }
+            catch (rateLimiterRes) {
+                if (rateLimiterRes instanceof Error)
+                    throw rateLimiterRes;
+                res.set('Retry-After', String(Math.round(rateLimiterRes.msBeforeNext / 1000)));
+                throw new HitRateLimitError({
+                    limit: +env['RATE_LIMITER_POINTS'],
+                    reset: new Date(Date.now() + rateLimiterRes.msBeforeNext),
+                });
+            }
         }
         next();
     });

package/dist/middleware/respond.js

@@ -1,8 +1,8 @@
+import { useEnv } from '@directus/env';
 import { parse as parseBytesConfiguration } from 'bytes';
 import { assign } from 'lodash-es';
 import { getCache, setCacheValue } from '../cache.js';
-import env from '../env.js';
-import logger from '../logger.js';
+import { useLogger } from '../logger.js';
 import { ExportService } from '../services/import-export/index.js';
 import { VersionsService } from '../services/versions.js';
 import asyncHandler from '../utils/async-handler.js';
@@ -12,6 +12,8 @@ import { getDateFormatted } from '../utils/get-date-formatted.js';
 import { getMilliseconds } from '../utils/get-milliseconds.js';
 import { stringByteSize } from '../utils/get-string-byte-size.js';
 export const respond = asyncHandler(async (req, res) => {
+    const env = useEnv();
+    const logger = useLogger();
     const { cache } = getCache();
     let exceedsMaxSize = false;
     if (env['CACHE_VALUE_MAX_SIZE'] !== false) {

package/dist/operations/log/index.js

@@ -1,9 +1,10 @@
 import { defineOperationApi } from '@directus/extensions';
 import { optionToString } from '@directus/utils';
-import logger from '../../logger.js';
+import { useLogger } from '../../logger.js';
 export default defineOperationApi({
     id: 'log',
     handler: ({ message }) => {
+        const logger = useLogger();
         logger.info(optionToString(message));
     },
 });

package/dist/rate-limiter.d.ts

@@ -1,4 +1,5 @@
 import type { IRateLimiterOptions, IRateLimiterStoreOptions, RateLimiterAbstract } from 'rate-limiter-flexible';
+import { RateLimiterRes } from 'rate-limiter-flexible';
 type IRateLimiterOptionsOverrides = Partial<IRateLimiterOptions> | Partial<IRateLimiterStoreOptions>;
 export declare function createRateLimiter(configPrefix?: string, configOverrides?: IRateLimiterOptionsOverrides): RateLimiterAbstract;
-export {};
+export { RateLimiterRes };

package/dist/rate-limiter.js

@@ -1,10 +1,11 @@
+import { useEnv } from '@directus/env';
 import { merge } from 'lodash-es';
-import { RateLimiterMemory, RateLimiterRedis } from 'rate-limiter-flexible';
-import env from './env.js';
+import { RateLimiterMemory, RateLimiterRedis, RateLimiterRes } from 'rate-limiter-flexible';
 import { getConfigFromEnv } from './utils/get-config-from-env.js';
 import { createRequire } from 'node:module';
 const require = createRequire(import.meta.url);
 export function createRateLimiter(configPrefix = 'RATE_LIMITER', configOverrides) {
+    const env = useEnv();
     switch (env['RATE_LIMITER_STORE']) {
         case 'redis':
             return new RateLimiterRedis(getConfig('redis', configPrefix, configOverrides));
@@ -13,10 +14,12 @@ export function createRateLimiter(configPrefix = 'RATE_LIMITER', configOverrides
             return new RateLimiterMemory(getConfig('memory', configPrefix, configOverrides));
     }
 }
+export { RateLimiterRes };
 function getConfig(store = 'memory', configPrefix = 'RATE_LIMITER', overrides) {
     const config = getConfigFromEnv(`${configPrefix}_`, `${configPrefix}_${store}_`);
     if (store === 'redis') {
         const Redis = require('ioredis');
+        const env = useEnv();
         config.storeClient = new Redis(env[`REDIS`] || getConfigFromEnv(`REDIS_`));
     }
     delete config.enabled;

package/dist/redis/index.d.ts

@@ -0,0 +1,3 @@
+export { createRedis } from './lib/create-redis.js';
+export { useRedis } from './lib/use-redis.js';
+export { redisConfigAvailable } from './utils/redis-config-available.js';

package/dist/redis/index.js

@@ -0,0 +1,3 @@
+export { createRedis } from './lib/create-redis.js';
+export { useRedis } from './lib/use-redis.js';
+export { redisConfigAvailable } from './utils/redis-config-available.js';

package/dist/redis/lib/create-redis.d.ts

@@ -0,0 +1,7 @@
+import { Redis } from 'ioredis';
+/**
+ * Create a new Redis instance based on the global env configuration
+ *
+ * @returns New Redis instance based on global configuration
+ */
+export declare const createRedis: () => Redis;

package/dist/redis/lib/create-redis.js

@@ -0,0 +1,12 @@
+import { useEnv } from '@directus/env';
+import { Redis } from 'ioredis';
+import { getConfigFromEnv } from '../../utils/get-config-from-env.js';
+/**
+ * Create a new Redis instance based on the global env configuration
+ *
+ * @returns New Redis instance based on global configuration
+ */
+export const createRedis = () => {
+    const env = useEnv();
+    return new Redis(env['REDIS'] ?? getConfigFromEnv('REDIS'));
+};

package/dist/redis/lib/use-redis.d.ts

@@ -0,0 +1,16 @@
+import { Redis } from 'ioredis';
+/**
+ * Memoization cache for useRedis
+ *
+ * @see {@link useRedis}
+ */
+export declare const _cache: {
+    redis: Redis | undefined;
+};
+/**
+ * Access the globally shared Redis instance
+ * Creates new Redis instance on first invocation
+ *
+ * @returns Globally shared Redis instance
+ */
+export declare const useRedis: () => Redis;

package/dist/redis/lib/use-redis.js

@@ -0,0 +1,22 @@
+import { Redis } from 'ioredis';
+import { createRedis } from './create-redis.js';
+/**
+ * Memoization cache for useRedis
+ *
+ * @see {@link useRedis}
+ */
+export const _cache = {
+    redis: undefined,
+};
+/**
+ * Access the globally shared Redis instance
+ * Creates new Redis instance on first invocation
+ *
+ * @returns Globally shared Redis instance
+ */
+export const useRedis = () => {
+    if (_cache.redis)
+        return _cache.redis;
+    _cache.redis = createRedis();
+    return _cache.redis;
+};

package/dist/redis/utils/redis-config-available.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Check if Redis configuration exists in the current project's environment configuration
+ */
+export declare const redisConfigAvailable: () => boolean;