@directus/api 14.1.2 → 15.0.0

package/dist/app.js

@@ -1,3 +1,4 @@
+import { InvalidPayloadError, ServiceUnavailableError } from '@directus/errors';
 import { handlePressure } from '@directus/pressure';
 import cookieParser from 'cookie-parser';
 import express from 'express';
@@ -40,7 +41,6 @@ import webhooksRouter from './controllers/webhooks.js';
 import { isInstalled, validateDatabaseConnection, validateDatabaseExtensions, validateMigrations, } from './database/index.js';
 import emitter from './emitter.js';
 import env from './env.js';
-import { InvalidPayloadError, ServiceUnavailableError } from '@directus/errors';
 import { getExtensionManager } from './extensions/index.js';
 import { getFlowManager } from './flows.js';
 import logger, { expressLogger } from './logger.js';
@@ -56,11 +56,11 @@ import rateLimiter from './middleware/rate-limiter-ip.js';
 import sanitizeQuery from './middleware/sanitize-query.js';
 import schema from './middleware/schema.js';
 import { getConfigFromEnv } from './utils/get-config-from-env.js';
-import { collectTelemetry } from './utils/telemetry.js';
 import { Url } from './utils/url.js';
 import { validateEnv } from './utils/validate-env.js';
 import { validateStorage } from './utils/validate-storage.js';
 import { init as initWebhooks } from './webhooks.js';
+import { initTelemetry } from './telemetry/index.js';
 const require = createRequire(import.meta.url);
 export default async function createApp() {
     const helmet = await import('helmet');
@@ -234,7 +234,7 @@ export default async function createApp() {
     await emitter.emitInit('routes.after', { app });
     // Register all webhooks
     await initWebhooks();
-    collectTelemetry();
+    initTelemetry();
     await emitter.emitInit('app.after', { app });
     return app;
 }

package/dist/auth/drivers/oauth2.js

@@ -1,14 +1,13 @@
-import { isDirectusError } from '@directus/errors';
+import { ErrorCode, InvalidCredentialsError, InvalidProviderConfigError, InvalidProviderError, InvalidTokenError, isDirectusError, ServiceUnavailableError, } from '@directus/errors';
 import { parseJSON } from '@directus/utils';
 import express, { Router } from 'express';
-import flatten from 'flat';
+import { flatten } from 'flat';
 import jwt from 'jsonwebtoken';
 import { errors, generators, Issuer } from 'openid-client';
 import { getAuthProvider } from '../../auth.js';
 import getDatabase from '../../database/index.js';
 import emitter from '../../emitter.js';
 import env from '../../env.js';
-import { ErrorCode, InvalidCredentialsError, InvalidProviderError, InvalidProviderConfigError, InvalidTokenError, ServiceUnavailableError, } from '@directus/errors';
 import logger from '../../logger.js';
 import { respond } from '../../middleware/respond.js';
 import { AuthenticationService } from '../../services/authentication.js';

package/dist/auth/drivers/openid.js

@@ -1,14 +1,13 @@
-import { isDirectusError } from '@directus/errors';
+import { ErrorCode, InvalidCredentialsError, InvalidProviderConfigError, InvalidProviderError, InvalidTokenError, isDirectusError, ServiceUnavailableError, } from '@directus/errors';
 import { parseJSON } from '@directus/utils';
 import express, { Router } from 'express';
-import flatten from 'flat';
+import { flatten } from 'flat';
 import jwt from 'jsonwebtoken';
 import { errors, generators, Issuer } from 'openid-client';
 import { getAuthProvider } from '../../auth.js';
 import getDatabase from '../../database/index.js';
 import emitter from '../../emitter.js';
 import env from '../../env.js';
-import { ErrorCode, InvalidCredentialsError, InvalidProviderError, InvalidProviderConfigError, InvalidTokenError, ServiceUnavailableError, } from '@directus/errors';
 import logger from '../../logger.js';
 import { respond } from '../../middleware/respond.js';
 import { AuthenticationService } from '../../services/authentication.js';

package/dist/cli/commands/schema/apply.js

@@ -41,92 +41,90 @@ export async function apply(snapshotPath, options) {
         const dryRun = options?.dryRun === true;
         const promptForChanges = !dryRun && options?.yes !== true;
         if (dryRun || promptForChanges) {
-            let message = '';
+            const sections = [];
             if (snapshotDiff.collections.length > 0) {
-                message += chalk.black.underline.bold('Collections:');
+                const lines = [chalk.underline.bold('Collections:')];
                 for (const { collection, diff } of snapshotDiff.collections) {
                     if (diff[0]?.kind === DiffKind.EDIT) {
-                        message += `\n  - ${chalk.blue('Update')} ${collection}`;
+                        lines.push(`  - ${chalk.magenta('Update')} ${collection}`);
                         for (const change of diff) {
                             if (change.kind === DiffKind.EDIT) {
-                                const path = change.path.slice(1).join('.');
-                                message += `\n    - Set ${path} to ${change.rhs}`;
+                                const path = formatPath(change.path);
+                                lines.push(`    - Set ${path} to ${change.rhs}`);
                             }
                         }
                     }
                     else if (diff[0]?.kind === DiffKind.DELETE) {
-                        message += `\n  - ${chalk.red('Delete')} ${collection}`;
+                        lines.push(`  - ${chalk.red('Delete')} ${collection}`);
                     }
                     else if (diff[0]?.kind === DiffKind.NEW) {
-                        message += `\n  - ${chalk.green('Create')} ${collection}`;
+                        lines.push(`  - ${chalk.green('Create')} ${collection}`);
                     }
                     else if (diff[0]?.kind === DiffKind.ARRAY) {
-                        message += `\n  - ${chalk.blue('Update')} ${collection}`;
+                        lines.push(`  - ${chalk.magenta('Update')} ${collection}`);
                     }
                 }
+                sections.push(lines.join('\n'));
             }
             if (snapshotDiff.fields.length > 0) {
-                message += '\n\n' + chalk.black.underline.bold('Fields:');
+                const lines = [chalk.underline.bold('Fields:')];
                 for (const { collection, field, diff } of snapshotDiff.fields) {
                     if (diff[0]?.kind === DiffKind.EDIT || isNestedMetaUpdate(diff[0])) {
-                        message += `\n  - ${chalk.blue('Update')} ${collection}.${field}`;
+                        lines.push(`  - ${chalk.magenta('Update')} ${collection}.${field}`);
                         for (const change of diff) {
-                            const path = change.path.slice(1).join('.');
+                            const path = formatPath(change.path);
                             if (change.kind === DiffKind.EDIT) {
-                                message += `\n    - Set ${path} to ${change.rhs}`;
+                                lines.push(`    - Set ${path} to ${change.rhs}`);
                             }
                             else if (change.kind === DiffKind.DELETE) {
-                                message += `\n    - Remove ${path}`;
+                                lines.push(`    - Remove ${path}`);
                             }
                             else if (change.kind === DiffKind.NEW) {
-                                message += `\n    - Add ${path} and set it to ${change.rhs}`;
+                                lines.push(`    - Add ${path} and set it to ${change.rhs}`);
                             }
                         }
                     }
                     else if (diff[0]?.kind === DiffKind.DELETE) {
-                        message += `\n  - ${chalk.red('Delete')} ${collection}.${field}`;
+                        lines.push(`  - ${chalk.red('Delete')} ${collection}.${field}`);
                     }
                     else if (diff[0]?.kind === DiffKind.NEW) {
-                        message += `\n  - ${chalk.green('Create')} ${collection}.${field}`;
+                        lines.push(`  - ${chalk.green('Create')} ${collection}.${field}`);
                     }
                     else if (diff[0]?.kind === DiffKind.ARRAY) {
-                        message += `\n  - ${chalk.blue('Update')} ${collection}.${field}`;
+                        lines.push(`  - ${chalk.magenta('Update')} ${collection}.${field}`);
                     }
                 }
+                sections.push(lines.join('\n'));
             }
             if (snapshotDiff.relations.length > 0) {
-                message += '\n\n' + chalk.black.underline.bold('Relations:');
+                const lines = [chalk.underline.bold('Relations:')];
                 for (const { collection, field, related_collection, diff } of snapshotDiff.relations) {
+                    const relatedCollection = formatRelatedCollection(related_collection);
                     if (diff[0]?.kind === DiffKind.EDIT) {
-                        message += `\n  - ${chalk.blue('Update')} ${collection}.${field}`;
+                        lines.push(`  - ${chalk.magenta('Update')} ${collection}.${field}${relatedCollection}`);
                         for (const change of diff) {
                             if (change.kind === DiffKind.EDIT) {
-                                const path = change.path.slice(1).join('.');
-                                message += `\n    - Set ${path} to ${change.rhs}`;
+                                const path = formatPath(change.path);
+                                lines.push(`    - Set ${path} to ${change.rhs}`);
                             }
                         }
                     }
                     else if (diff[0]?.kind === DiffKind.DELETE) {
-                        message += `\n  - ${chalk.red('Delete')} ${collection}.${field}`;
+                        lines.push(`  - ${chalk.red('Delete')} ${collection}.${field}${relatedCollection}`);
                     }
                     else if (diff[0]?.kind === DiffKind.NEW) {
-                        message += `\n  - ${chalk.green('Create')} ${collection}.${field}`;
+                        lines.push(`  - ${chalk.green('Create')} ${collection}.${field}${relatedCollection}`);
                     }
                     else if (diff[0]?.kind === DiffKind.ARRAY) {
-                        message += `\n  - ${chalk.blue('Update')} ${collection}.${field}`;
-                    }
-                    else {
-                        continue;
-                    }
-                    // Related collection doesn't exist for a2o relationship types
-                    if (related_collection) {
-                        message += `-> ${related_collection}`;
+                        lines.push(`  - ${chalk.magenta('Update')} ${collection}.${field}${relatedCollection}`);
                     }
                 }
+                sections.push(lines.join('\n'));
             }
-            message = 'The following changes will be applied:\n\n' + chalk.black(message);
+            const message = 'The following changes will be applied:\n\n' + sections.join('\n\n');
             if (dryRun) {
-                logger.info(message);
+                // eslint-disable-next-line no-console
+                console.log(message);
                 process.exit(0);
             }
             const { proceed } = await inquirer.prompt([
@@ -151,3 +149,16 @@ export async function apply(snapshotPath, options) {
         process.exit(1);
     }
 }
+function formatPath(path) {
+    if (path.length === 1) {
+        return path.toString();
+    }
+    return path.slice(1).join('.');
+}
+function formatRelatedCollection(relatedCollection) {
+    // Related collection doesn't exist for a2o relationship types
+    if (relatedCollection) {
+        return ` → ${relatedCollection}`;
+    }
+    return '';
+}

package/dist/cli/index.js

@@ -1,7 +1,7 @@
 import { Command, Option } from 'commander';
+import { version } from 'directus/version';
 import emitter from '../emitter.js';
 import { startServer } from '../server.js';
-import * as pkg from '../utils/package.js';
 import bootstrap from './commands/bootstrap/index.js';
 import count from './commands/count/index.js';
 import dbInstall from './commands/database/install.js';
@@ -20,7 +20,7 @@ export async function createCli() {
     await loadExtensions();
     await emitter.emitInit('cli.before', { program });
     program.name('directus').usage('[command] [options]');
-    program.version(pkg.version, '-v, --version');
+    program.version(version, '-v, --version');
     program.command('start').description('Start the Directus API').action(startServer);
     program.command('init').description('Create a new Directus Project').action(init);
     // Security

package/dist/database/index.d.ts

@@ -1,7 +1,8 @@
 import type { SchemaInspector } from '@directus/schema';
 import type { Knex } from 'knex';
 import type { DatabaseClient } from '../types/index.js';
-export default function getDatabase(): Knex;
+export default getDatabase;
+export declare function getDatabase(): Knex;
 export declare function getSchemaInspector(): SchemaInspector;
 /**
  * Get database version. Value currently exists for MySQL only.

package/dist/database/index.js

@@ -17,7 +17,8 @@ let database = null;
 let inspector = null;
 let databaseVersion = null;
 const __dirname = dirname(fileURLToPath(import.meta.url));
-export default function getDatabase() {
+export default getDatabase;
+export function getDatabase() {
     if (database) {
         return database;
     }

package/dist/database/system-data/relations/relations.yaml

@@ -96,6 +96,10 @@ data:
     many_field: public_background
     one_collection: directus_files
 
+  - many_collection: directus_settings
+    many_field: public_favicon
+    one_collection: directus_files
+
   - many_collection: directus_settings
     many_field: storage_default_folder
     one_collection: directus_folders

package/dist/emitter.d.ts

@@ -17,4 +17,5 @@ export declare class Emitter {
     offAll(): void;
 }
 declare const emitter: Emitter;
+export declare const useEmitter: () => Emitter;
 export default emitter;

package/dist/emitter.js

@@ -1,6 +1,6 @@
 import ee2 from 'eventemitter2';
-import logger from './logger.js';
 import getDatabase from './database/index.js';
+import logger from './logger.js';
 export class Emitter {
     filterEmitter;
     actionEmitter;
@@ -84,4 +84,5 @@ export class Emitter {
     }
 }
 const emitter = new Emitter();
+export const useEmitter = () => emitter;
 export default emitter;

package/dist/env.d.ts

@@ -5,6 +5,7 @@
 export declare const defaults: Record<string, any>;
 declare let env: Record<string, any>;
 export default env;
+export declare const useEnv: () => Record<string, any>;
 /**
  * When changes have been made during runtime, like in the CLI, we can refresh the env object with
  * the newly created variables

package/dist/env.js

@@ -160,6 +160,7 @@ const allowedEnvironmentVars = [
     'PACKAGE_FILE_LOCATION',
     'EXTENSIONS_LOCATION',
     'EXTENSIONS_PATH',
+    'EXTENSIONS_MUST_LOAD',
     'EXTENSIONS_AUTO_RELOAD',
     'EXTENSIONS_CACHE_TTL',
     'EXTENSIONS_SANDBOX_MEMORY',
@@ -196,6 +197,8 @@ const allowedEnvironmentVars = [
     'ADMIN_PASSWORD',
     // telemetry
     'TELEMETRY',
+    'TELEMETRY_URL',
+    'TELEMETRY_AUTHORIZATION',
     // limits & optimization
     'RELATIONAL_BATCH_SIZE',
     'EXPORT_BATCH_SIZE',
@@ -260,6 +263,7 @@ export const defaults = {
     AUTH_DISABLE_DEFAULT: false,
     PACKAGE_FILE_LOCATION: '.',
     EXTENSIONS_PATH: './extensions',
+    EXTENSIONS_MUST_LOAD: false,
     EXTENSIONS_AUTO_RELOAD: false,
     EXTENSIONS_SANDBOX_MEMORY: 100,
     EXTENSIONS_SANDBOX_TIMEOUT: 1000,
@@ -269,6 +273,7 @@ export const defaults = {
     EMAIL_SENDMAIL_NEW_LINE: 'unix',
     EMAIL_SENDMAIL_PATH: '/usr/sbin/sendmail',
     TELEMETRY: true,
+    TELEMETRY_URL: 'https://telemetry.directus.io',
     ASSETS_CACHE_TTL: '30d',
     ASSETS_TRANSFORM_MAX_CONCURRENT: 25,
     ASSETS_TRANSFORM_IMAGE_MAX_DIMENSION: 6000,
@@ -336,6 +341,7 @@ let env = {
 process.env = env;
 env = processValues(env);
 export default env;
+export const useEnv = () => env;
 /**
  * When changes have been made during runtime, like in the CLI, we can refresh the env object with
  * the newly created variables

package/dist/extensions/lib/get-shared-deps-mapping.js

@@ -12,7 +12,7 @@ export const getSharedDepsMapping = async (deps) => {
     const appDir = await readdir(path.join(resolvePackage('@directus/app', __dirname), 'dist', 'assets'));
     const depsMapping = {};
     for (const dep of deps) {
-        const depRegex = new RegExp(`${escapeRegExp(dep.replace(/\//g, '_'))}\\.[0-9a-f]{8}\\.entry\\.js`);
+        const depRegex = new RegExp(`${escapeRegExp(dep.replace(/\//g, '_'))}\\.[a-zA-Z0-9_-]{8}\\.entry\\.js`);
         const depName = appDir.find((file) => depRegex.test(file));
         if (depName) {
             const depUrl = new Url(env['PUBLIC_URL']).addPath('admin', 'assets', depName);

package/dist/extensions/lib/sandbox/register/route.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="node" resolution-mode="require"/>
 import type { Router } from 'express';
 import type { Reference } from 'isolated-vm';
 import type { IncomingHttpHeaders } from 'node:http';

package/dist/extensions/manager.d.ts

@@ -155,4 +155,9 @@ export declare class ExtensionManager {
      * Remove the registration for all API extensions
      */
     private unregisterApiExtensions;
+    /**
+     * If extensions must load successfully, any errors will cause the process to exit.
+     * Otherwise, the error will only be logged as a warning.
+     */
+    private handleExtensionError;
 }

package/dist/extensions/manager.js

@@ -27,6 +27,7 @@ import { getSchema } from '../utils/get-schema.js';
 import { importFileUrl } from '../utils/import-file-url.js';
 import { JobQueue } from '../utils/job-queue.js';
 import { scheduleSynchronizedJob, validateCron } from '../utils/schedule.js';
+import { toBoolean } from '../utils/to-boolean.js';
 import { getExtensionsPath } from './lib/get-extensions-path.js';
 import { getExtensionsSettings } from './lib/get-extensions-settings.js';
 import { getExtensions } from './lib/get-extensions.js';
@@ -146,8 +147,7 @@ export class ExtensionManager {
             this.extensionsSettings = await getExtensionsSettings(this.extensions);
         }
         catch (error) {
-            logger.warn(`Couldn't load extensions`);
-            logger.warn(error);
+            this.handleExtensionError({ error, reason: `Couldn't load extensions` });
         }
         await this.registerHooks();
         await this.registerEndpoints();
@@ -292,7 +292,7 @@ export class ExtensionManager {
             find: name,
             replacement: path,
         }));
-        const entrypoint = generateExtensionsEntrypoint(this.extensions);
+        const entrypoint = generateExtensionsEntrypoint(this.extensions, this.extensionsSettings);
         try {
             const bundle = await rollup({
                 input: 'entry',
@@ -322,9 +322,9 @@ export class ExtensionManager {
         const extensionCode = await readFile(entrypointPath, 'utf-8');
         const isolate = new ivm.Isolate({
             memoryLimit: sandboxMemory,
-            onCatastrophicError: (e) => {
+            onCatastrophicError: (error) => {
                 logger.error(`Error in API extension sandbox of ${extension.type} "${extension.name}"`);
-                logger.error(e);
+                logger.error(error);
                 process.abort();
             },
         });
@@ -377,8 +377,7 @@ export class ExtensionManager {
                 }
             }
             catch (error) {
-                logger.warn(`Couldn't register hook "${hook.name}"`);
-                logger.warn(error);
+                this.handleExtensionError({ error, reason: `Couldn't register hook "${hook.name}"` });
             }
         }
     }
@@ -410,8 +409,7 @@ export class ExtensionManager {
                 }
             }
             catch (error) {
-                logger.warn(`Couldn't register endpoint "${endpoint.name}"`);
-                logger.warn(error);
+                this.handleExtensionError({ error, reason: `Couldn't register endpoint "${endpoint.name}"` });
             }
         }
     }
@@ -449,8 +447,7 @@ export class ExtensionManager {
                 }
             }
             catch (error) {
-                logger.warn(`Couldn't register operation "${operation.name}"`);
-                logger.warn(error);
+                this.handleExtensionError({ error, reason: `Couldn't register operation "${operation.name}"` });
             }
         }
     }
@@ -460,6 +457,12 @@ export class ExtensionManager {
      */
     async registerBundles() {
         const bundles = this.extensions.filter((extension) => extension.type === 'bundle');
+        const extensionEnabled = (extensionName) => {
+            const settings = this.extensionsSettings.find(({ name }) => name === extensionName);
+            if (!settings)
+                return false;
+            return settings.enabled;
+        };
         for (const bundle of bundles) {
             try {
                 const bundlePath = path.resolve(bundle.path, bundle.entrypoint.api);
@@ -469,14 +472,20 @@ export class ExtensionManager {
                 const configs = getModuleDefault(bundleInstances);
                 const unregisterFunctions = [];
                 for (const { config, name } of configs.hooks) {
+                    if (!extensionEnabled(`${bundle.name}/${name}`))
+                        continue;
                     const unregisters = this.registerHook(config, name);
                     unregisterFunctions.push(...unregisters);
                 }
                 for (const { config, name } of configs.endpoints) {
+                    if (!extensionEnabled(`${bundle.name}/${name}`))
+                        continue;
                     const unregister = this.registerEndpoint(config, name);
                     unregisterFunctions.push(unregister);
                 }
-                for (const { config } of configs.operations) {
+                for (const { config, name } of configs.operations) {
+                    if (!extensionEnabled(`${bundle.name}/${name}`))
+                        continue;
                     const unregister = this.registerOperation(config);
                     unregisterFunctions.push(unregister);
                 }
@@ -486,8 +495,7 @@ export class ExtensionManager {
                 });
             }
             catch (error) {
-                logger.warn(`Couldn't register bundle "${bundle.name}"`);
-                logger.warn(error);
+                this.handleExtensionError({ error, reason: `Couldn't register bundle "${bundle.name}"` });
             }
         }
     }
@@ -534,7 +542,7 @@ export class ExtensionManager {
                     });
                 }
                 else {
-                    logger.warn(`Couldn't register cron hook. Provided cron is invalid: ${cron}`);
+                    this.handleExtensionError({ reason: `Couldn't register cron hook. Provided cron is invalid: ${cron}` });
                 }
             },
             embed: (position, code) => {
@@ -556,7 +564,7 @@ export class ExtensionManager {
                     }
                 }
                 else {
-                    logger.warn(`Couldn't register embed hook. Provided code is empty!`);
+                    this.handleExtensionError({ reason: `Couldn't register embed hook. Provided code is empty!` });
                 }
             },
         };
@@ -610,4 +618,22 @@ export class ExtensionManager {
         const unregisterFunctions = Array.from(this.unregisterFunctionMap.values());
         await Promise.all(unregisterFunctions.map((fn) => fn()));
     }
+    /**
+     * If extensions must load successfully, any errors will cause the process to exit.
+     * Otherwise, the error will only be logged as a warning.
+     */
+    handleExtensionError({ error, reason }) {
+        if (toBoolean(env['EXTENSIONS_MUST_LOAD'])) {
+            logger.error('EXTENSION_MUST_LOAD is enabled and an extension failed to load.');
+            logger.error(reason);
+            if (error)
+                logger.error(error);
+            process.exit(1);
+        }
+        else {
+            logger.warn(reason);
+            if (error)
+                logger.warn(error);
+        }
+    }
 }

package/dist/logger.d.ts

@@ -2,7 +2,8 @@
 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>>;
+declare const logger: import("pino").Logger<never>;
 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 declare const useLogger: () => import("pino").Logger<never>;
 export default logger;

package/dist/logger.js

@@ -105,6 +105,7 @@ export const expressLogger = pinoHttp({
         },
     },
 });
+export const useLogger = () => logger;
 export default logger;
 function redactQuery(originalPath) {
     const url = new URL(originalPath, 'http://example.com/');

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

@@ -10,17 +10,20 @@ 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/redis/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/create-redis.js

@@ -0,0 +1,12 @@
+import { Redis } from 'ioredis';
+import { useEnv } from '../env.js';
+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/index.d.ts

@@ -0,0 +1,2 @@
+export { useRedis } from './use-redis.js';
+export { createRedis } from './create-redis.js';

package/dist/redis/index.js

@@ -0,0 +1,2 @@
+export { useRedis } from './use-redis.js';
+export { createRedis } from './create-redis.js';

package/dist/redis/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/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;
+};