directus 9.4.1 → 9.5.1

package/dist/database/migrations/20211230A-add-project-descriptor.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.down = exports.up = void 0;
+async function up(knex) {
+    await knex.schema.alterTable('directus_settings', (table) => {
+        table.string('project_descriptor', 100).nullable();
+    });
+}
+exports.up = up;
+async function down(knex) {
+    await knex.schema.alterTable('directus_settings', (table) => {
+        table.dropColumn('project_descriptor');
+    });
+}
+exports.down = down;

package/dist/database/migrations/run.js

@@ -13,7 +13,7 @@ async function run(database, direction, log = true) {
     let migrationFiles = await fs_extra_1.default.readdir(__dirname);
     const customMigrationsPath = path_1.default.resolve(env_1.default.EXTENSIONS_PATH, 'migrations');
     let customMigrationFiles = ((await fs_extra_1.default.pathExists(customMigrationsPath)) && (await fs_extra_1.default.readdir(customMigrationsPath))) || [];
-    migrationFiles = migrationFiles.filter((file) => file.startsWith('run') === false && file.endsWith('.d.ts') === false);
+    migrationFiles = migrationFiles.filter((file) => /^[0-9]+[A-Z]-[^.]+\.(?:js|ts)$/.test(file));
     customMigrationFiles = customMigrationFiles.filter((file) => file.endsWith('.js'));
     const completedMigrations = await database.select('*').from('directus_migrations').orderBy('version');
     const migrations = [

package/dist/database/run-ast.d.ts

@@ -1,5 +1,5 @@
 import { Knex } from 'knex';
-import { Item, SchemaOverview } from '../types';
+import { Item, SchemaOverview } from '@directus/shared/types';
 import { AST, NestedCollectionNode } from '../types/ast';
 declare type RunASTOptions = {
     /**

package/dist/database/seeds/01-collections.yaml

@@ -5,6 +5,7 @@ columns:
     type: string
     length: 64
     primary: true
+    nullable: false
   icon:
     type: string
     length: 30

package/dist/database/seeds/02-roles.yaml

@@ -4,6 +4,7 @@ columns:
   id:
     type: uuid
     primary: true
+    nullable: false
   name:
     type: string
     length: 100

package/dist/database/seeds/03-users.yaml

@@ -4,6 +4,7 @@ columns:
   id:
     type: uuid
     primary: true
+    nullable: false
   first_name:
     type: string
     length: 50

package/dist/database/system-data/fields/settings.yaml

@@ -14,6 +14,16 @@ fields:
       translations: Name
     width: half
 
+  - field: project_descriptor
+    interface: input
+    options:
+      iconRight: title
+      placeholder: $t:field_options.directus_settings.project_name_placeholder
+    translations:
+      language: en-US
+      translations: Name
+    width: half
+
   - field: project_url
     interface: input
     options:
@@ -22,7 +32,7 @@ fields:
     translations:
       language: en-US
       translations: Website
-    width: half
+    width: full
 
   - field: branding_divider
     interface: presentation-divider

package/dist/database/system-data/relations/index.d.ts

@@ -1,2 +1,2 @@
-import { RelationMeta } from '../../../types';
+import { RelationMeta } from '@directus/shared/types';
 export declare const systemRelationRows: RelationMeta[];

package/dist/emitter.d.ts

@@ -1,11 +1,11 @@
-import { ActionHandler, FilterHandler, HookContext, InitHandler } from './types';
+import { ActionHandler, EventContext, FilterHandler, InitHandler } from '@directus/shared/types';
 export declare class Emitter {
     private filterEmitter;
     private actionEmitter;
     private initEmitter;
     constructor();
-    emitFilter<T>(event: string, payload: T, meta: Record<string, any>, context: HookContext): Promise<T>;
-    emitAction(event: string, meta: Record<string, any>, context: HookContext): void;
+    emitFilter<T>(event: string | string[], payload: T, meta: Record<string, any>, context: EventContext): Promise<T>;
+    emitAction(event: string | string[], meta: Record<string, any>, context: EventContext): void;
     emitInit(event: string, meta: Record<string, any>): Promise<void>;
     onFilter(event: string, handler: FilterHandler): void;
     onAction(event: string, handler: ActionHandler): void;
@@ -14,7 +14,6 @@ export declare class Emitter {
     offAction(event: string, handler: ActionHandler): void;
     offInit(event: string, handler: InitHandler): void;
     offAll(): void;
-    private eventsToEmit;
 }
 declare const emitter: Emitter;
 export default emitter;

package/dist/emitter.js

@@ -20,7 +20,7 @@ class Emitter {
         this.initEmitter = new eventemitter2_1.EventEmitter2(emitterOptions);
     }
     async emitFilter(event, payload, meta, context) {
-        const events = this.eventsToEmit(event, meta);
+        const events = Array.isArray(event) ? event : [event];
         const listeners = events.flatMap((event) => this.filterEmitter.listeners(event));
         let updatedPayload = payload;
         for (const listener of listeners) {
@@ -32,7 +32,7 @@ class Emitter {
         return updatedPayload;
     }
     emitAction(event, meta, context) {
-        const events = this.eventsToEmit(event, meta);
+        const events = Array.isArray(event) ? event : [event];
         for (const event of events) {
             this.actionEmitter.emitAsync(event, meta, context).catch((err) => {
                 logger_1.default.warn(`An error was thrown while executing action "${event}"`);
@@ -72,12 +72,6 @@ class Emitter {
         this.actionEmitter.removeAllListeners();
         this.initEmitter.removeAllListeners();
     }
-    eventsToEmit(event, meta) {
-        if (event.startsWith('items')) {
-            return [event, `${meta.collection}.${event}`];
-        }
-        return [event];
-    }
 }
 exports.Emitter = Emitter;
 const emitter = new Emitter();

package/dist/env.js

@@ -52,6 +52,7 @@ const defaults = {
     AUTH_PROVIDERS: '',
     AUTH_DISABLE_DEFAULT: false,
     EXTENSIONS_PATH: './extensions',
+    EXTENSIONS_AUTO_RELOAD: false,
     EMAIL_FROM: 'no-reply@directus.io',
     EMAIL_TRANSPORT: 'sendmail',
     EMAIL_SENDMAIL_NEW_LINE: 'unix',
@@ -61,6 +62,8 @@ const defaults = {
     ASSETS_TRANSFORM_MAX_CONCURRENT: 1,
     ASSETS_TRANSFORM_IMAGE_MAX_DIMENSION: 6000,
     ASSETS_TRANSFORM_MAX_OPERATIONS: 5,
+    IP_TRUST_PROXY: true,
+    IP_CUSTOM_HEADER: false,
     SERVE_APP: true,
 };
 // Allows us to force certain environment variable into a type, instead of relying

package/dist/exceptions/database/translate.js

@@ -46,6 +46,7 @@ async function translateDatabaseError(error) {
         case 'mysql':
             defaultError = (0, mysql_1.extractError)(error);
             break;
+        case 'cockroachdb':
         case 'postgres':
             defaultError = (0, postgres_1.extractError)(error);
             break;

package/dist/exceptions/index.d.ts

@@ -14,5 +14,6 @@ export * from './range-not-satisfiable';
 export * from './route-not-found';
 export * from './service-unavailable';
 export * from './unprocessable-entity';
+export * from './unsupported-media-type';
 export * from './user-suspended';
 export * from './unexpected-response';

package/dist/exceptions/index.js

@@ -26,5 +26,6 @@ __exportStar(require("./range-not-satisfiable"), exports);
 __exportStar(require("./route-not-found"), exports);
 __exportStar(require("./service-unavailable"), exports);
 __exportStar(require("./unprocessable-entity"), exports);
+__exportStar(require("./unsupported-media-type"), exports);
 __exportStar(require("./user-suspended"), exports);
 __exportStar(require("./unexpected-response"), exports);

package/dist/exceptions/unsupported-media-type.d.ts

@@ -0,0 +1,4 @@
+import { BaseException } from '@directus/shared/exceptions';
+export declare class UnsupportedMediaTypeException extends BaseException {
+    constructor(message: string, extensions?: Record<string, unknown>);
+}

package/dist/exceptions/unsupported-media-type.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnsupportedMediaTypeException = void 0;
+const exceptions_1 = require("@directus/shared/exceptions");
+class UnsupportedMediaTypeException extends exceptions_1.BaseException {
+    constructor(message, extensions) {
+        super(message, 415, 'UNSUPPORTED_MEDIA_TYPE', extensions);
+    }
+}
+exports.UnsupportedMediaTypeException = UnsupportedMediaTypeException;

package/dist/extensions.d.ts

@@ -1,23 +1,29 @@
 import { Router } from 'express';
 import { AppExtensionType, ExtensionType } from '@directus/shared/types';
 export declare function getExtensionManager(): ExtensionManager;
+declare type Options = {
+    schedule: boolean;
+    watch: boolean;
+};
 declare class ExtensionManager {
-    private isInitialized;
+    private isLoaded;
+    private options;
     private extensions;
     private appExtensions;
-    private apiHooks;
-    private apiEndpoints;
+    private apiExtensions;
     private apiEmitter;
     private endpointRouter;
-    private isScheduleHookEnabled;
+    private watcher;
     constructor();
-    initialize({ schedule }?: {
-        schedule: boolean;
-    }): Promise<void>;
+    initialize(options?: Partial<Options>): Promise<void>;
     reload(): Promise<void>;
-    listExtensions(type?: ExtensionType): string[];
+    getExtensionsList(type?: ExtensionType): string[];
     getAppExtensions(type: AppExtensionType): string | undefined;
     getEndpointRouter(): Router;
+    private load;
+    private unload;
+    private initializeWatcher;
+    private updateWatchedExtensions;
     private getExtensions;
     private generateExtensionBundles;
     private getSharedDepsMapping;

package/dist/extensions.js

@@ -45,6 +45,8 @@ const plugin_alias_1 = __importDefault(require("@rollup/plugin-alias"));
 const url_1 = require("./utils/url");
 const get_module_default_1 = __importDefault(require("./utils/get-module-default"));
 const lodash_1 = require("lodash");
+const chokidar_1 = __importDefault(require("chokidar"));
+const utils_1 = require("@directus/shared/utils");
 let extensionManager;
 function getExtensionManager() {
     if (extensionManager) {
@@ -54,21 +56,73 @@ function getExtensionManager() {
     return extensionManager;
 }
 exports.getExtensionManager = getExtensionManager;
+const defaultOptions = {
+    schedule: true,
+    watch: env_1.default.EXTENSIONS_AUTO_RELOAD && env_1.default.NODE_ENV !== 'development',
+};
 class ExtensionManager {
     constructor() {
-        this.isInitialized = false;
+        this.isLoaded = false;
         this.extensions = [];
         this.appExtensions = {};
-        this.apiHooks = [];
-        this.apiEndpoints = [];
-        this.isScheduleHookEnabled = true;
+        this.apiExtensions = { hooks: [], endpoints: [] };
+        this.watcher = null;
+        this.options = defaultOptions;
         this.apiEmitter = new emitter_1.Emitter();
         this.endpointRouter = (0, express_1.Router)();
     }
-    async initialize({ schedule } = { schedule: true }) {
-        this.isScheduleHookEnabled = schedule;
-        if (this.isInitialized)
-            return;
+    async initialize(options = {}) {
+        this.options = {
+            ...defaultOptions,
+            ...options,
+        };
+        this.initializeWatcher();
+        if (!this.isLoaded) {
+            await this.load();
+            this.updateWatchedExtensions(this.extensions);
+            const loadedExtensions = this.getExtensionsList();
+            if (loadedExtensions.length > 0) {
+                logger_1.default.info(`Loaded extensions: ${loadedExtensions.join(', ')}`);
+            }
+        }
+    }
+    async reload() {
+        if (this.isLoaded) {
+            logger_1.default.info('Reloading extensions');
+            const prevExtensions = (0, lodash_1.clone)(this.extensions);
+            await this.unload();
+            await this.load();
+            const added = this.extensions.filter((extension) => !prevExtensions.some((prevExtension) => extension.path === prevExtension.path));
+            const removed = prevExtensions.filter((prevExtension) => !this.extensions.some((extension) => prevExtension.path === extension.path));
+            this.updateWatchedExtensions(added, removed);
+            const addedExtensions = added.map((extension) => extension.name);
+            const removedExtensions = removed.map((extension) => extension.name);
+            if (addedExtensions.length > 0) {
+                logger_1.default.info(`Added extensions: ${addedExtensions.join(', ')}`);
+            }
+            if (removedExtensions.length > 0) {
+                logger_1.default.info(`Removed extensions: ${removedExtensions.join(', ')}`);
+            }
+        }
+        else {
+            logger_1.default.warn('Extensions have to be loaded before they can be reloaded');
+        }
+    }
+    getExtensionsList(type) {
+        if (type === undefined) {
+            return this.extensions.map((extension) => extension.name);
+        }
+        else {
+            return this.extensions.filter((extension) => extension.type === type).map((extension) => extension.name);
+        }
+    }
+    getAppExtensions(type) {
+        return this.appExtensions[type];
+    }
+    getEndpointRouter() {
+        return this.endpointRouter;
+    }
+    async load() {
         try {
             await (0, node_1.ensureExtensionDirs)(env_1.default.EXTENSIONS_PATH, env_1.default.SERVE_APP ? constants_1.EXTENSION_TYPES : constants_1.API_EXTENSION_TYPES);
             this.extensions = await this.getExtensions();
@@ -82,38 +136,42 @@ class ExtensionManager {
         if (env_1.default.SERVE_APP) {
             this.appExtensions = await this.generateExtensionBundles();
         }
-        const loadedExtensions = this.listExtensions();
-        if (loadedExtensions.length > 0) {
-            logger_1.default.info(`Loaded extensions: ${loadedExtensions.join(', ')}`);
-        }
-        this.isInitialized = true;
+        this.isLoaded = true;
     }
-    async reload() {
-        if (!this.isInitialized)
-            return;
-        logger_1.default.info('Reloading extensions');
+    async unload() {
         this.unregisterHooks();
         this.unregisterEndpoints();
         this.apiEmitter.offAll();
         if (env_1.default.SERVE_APP) {
             this.appExtensions = {};
         }
-        this.isInitialized = false;
-        await this.initialize();
+        this.isLoaded = false;
     }
-    listExtensions(type) {
-        if (type === undefined) {
-            return this.extensions.map((extension) => extension.name);
-        }
-        else {
-            return this.extensions.filter((extension) => extension.type === type).map((extension) => extension.name);
+    initializeWatcher() {
+        if (this.options.watch && !this.watcher) {
+            logger_1.default.info('Watching extensions for changes...');
+            const localExtensionPaths = (env_1.default.SERVE_APP ? constants_1.EXTENSION_TYPES : constants_1.API_EXTENSION_TYPES).map((type) => path_1.default.posix.join(path_1.default.relative('.', env_1.default.EXTENSIONS_PATH).split(path_1.default.sep).join(path_1.default.posix.sep), (0, utils_1.pluralize)(type), '*', 'index.js'));
+            this.watcher = chokidar_1.default.watch([path_1.default.resolve('.', 'package.json'), ...localExtensionPaths], {
+                ignoreInitial: true,
+            });
+            this.watcher
+                .on('add', () => this.reload())
+                .on('change', () => this.reload())
+                .on('unlink', () => this.reload());
         }
     }
-    getAppExtensions(type) {
-        return this.appExtensions[type];
-    }
-    getEndpointRouter() {
-        return this.endpointRouter;
+    updateWatchedExtensions(added, removed = []) {
+        if (this.watcher) {
+            const toPackageExtensionPaths = (extensions) => extensions
+                .filter((extension) => !extension.local)
+                .map((extension) => extension.type !== 'pack'
+                ? path_1.default.resolve(extension.path, extension.entrypoint || '')
+                : path_1.default.resolve(extension.path, 'package.json'));
+            const addedPackageExtensionPaths = toPackageExtensionPaths(added);
+            const removedPackageExtensionPaths = toPackageExtensionPaths(removed);
+            this.watcher.add(addedPackageExtensionPaths);
+            this.watcher.unwatch(removedPackageExtensionPaths);
+        }
     }
     async getExtensions() {
         const packageExtensions = await (0, node_1.getPackageExtensions)('.', env_1.default.SERVE_APP ? constants_1.EXTENSION_PACKAGE_TYPES : constants_1.API_EXTENSION_PACKAGE_TYPES);
@@ -129,15 +187,21 @@ class ExtensionManager {
         const bundles = {};
         for (const extensionType of constants_1.APP_EXTENSION_TYPES) {
             const entry = (0, node_1.generateExtensionsEntry)(extensionType, this.extensions);
-            const bundle = await (0, rollup_1.rollup)({
-                input: 'entry',
-                external: Object.values(sharedDepsMapping),
-                makeAbsoluteExternalsRelative: false,
-                plugins: [(0, plugin_virtual_1.default)({ entry }), (0, plugin_alias_1.default)({ entries: internalImports })],
-            });
-            const { output } = await bundle.generate({ format: 'es', compact: true });
-            bundles[extensionType] = output[0].code;
-            await bundle.close();
+            try {
+                const bundle = await (0, rollup_1.rollup)({
+                    input: 'entry',
+                    external: Object.values(sharedDepsMapping),
+                    makeAbsoluteExternalsRelative: false,
+                    plugins: [(0, plugin_virtual_1.default)({ entry }), (0, plugin_alias_1.default)({ entries: internalImports })],
+                });
+                const { output } = await bundle.generate({ format: 'es', compact: true });
+                bundles[extensionType] = output[0].code;
+                await bundle.close();
+            }
+            catch (error) {
+                logger_1.default.warn(`Couldn't bundle App extensions`);
+                logger_1.default.warn(error);
+            }
         }
         return bundles;
     }
@@ -185,38 +249,39 @@ class ExtensionManager {
         const hookPath = path_1.default.resolve(hook.path, hook.entrypoint || '');
         const hookInstance = require(hookPath);
         const register = (0, get_module_default_1.default)(hookInstance);
+        const hookHandler = {
+            path: hookPath,
+            events: [],
+        };
         const registerFunctions = {
             filter: (event, handler) => {
                 emitter_1.default.onFilter(event, handler);
-                this.apiHooks.push({
+                hookHandler.events.push({
                     type: 'filter',
-                    path: hookPath,
-                    event,
+                    name: event,
                     handler,
                 });
             },
             action: (event, handler) => {
                 emitter_1.default.onAction(event, handler);
-                this.apiHooks.push({
+                hookHandler.events.push({
                     type: 'action',
-                    path: hookPath,
-                    event,
+                    name: event,
                     handler,
                 });
             },
             init: (event, handler) => {
                 emitter_1.default.onInit(event, handler);
-                this.apiHooks.push({
+                hookHandler.events.push({
                     type: 'init',
-                    path: hookPath,
-                    event,
+                    name: event,
                     handler,
                 });
             },
             schedule: (cron, handler) => {
                 if ((0, node_cron_1.validate)(cron)) {
                     const task = (0, node_cron_1.schedule)(cron, async () => {
-                        if (this.isScheduleHookEnabled) {
+                        if (this.options.schedule) {
                             try {
                                 await handler();
                             }
@@ -225,9 +290,8 @@ class ExtensionManager {
                             }
                         }
                     });
-                    this.apiHooks.push({
+                    hookHandler.events.push({
                         type: 'schedule',
-                        path: hookPath,
                         task,
                     });
                 }
@@ -245,6 +309,7 @@ class ExtensionManager {
             logger: logger_1.default,
             getSchema: get_schema_1.getSchema,
         });
+        this.apiExtensions.hooks.push(hookHandler);
     }
     registerEndpoint(endpoint, router) {
         const endpointPath = path_1.default.resolve(endpoint.path, endpoint.entrypoint || '');
@@ -263,35 +328,37 @@ class ExtensionManager {
             logger: logger_1.default,
             getSchema: get_schema_1.getSchema,
         });
-        this.apiEndpoints.push({
+        this.apiExtensions.endpoints.push({
             path: endpointPath,
         });
     }
     unregisterHooks() {
-        for (const hook of this.apiHooks) {
-            switch (hook.type) {
-                case 'filter':
-                    emitter_1.default.offFilter(hook.event, hook.handler);
-                    break;
-                case 'action':
-                    emitter_1.default.offAction(hook.event, hook.handler);
-                    break;
-                case 'init':
-                    emitter_1.default.offInit(hook.event, hook.handler);
-                    break;
-                case 'schedule':
-                    hook.task.destroy();
-                    break;
+        for (const hook of this.apiExtensions.hooks) {
+            for (const event of hook.events) {
+                switch (event.type) {
+                    case 'filter':
+                        emitter_1.default.offFilter(event.name, event.handler);
+                        break;
+                    case 'action':
+                        emitter_1.default.offAction(event.name, event.handler);
+                        break;
+                    case 'init':
+                        emitter_1.default.offInit(event.name, event.handler);
+                        break;
+                    case 'schedule':
+                        event.task.stop();
+                        break;
+                }
             }
             delete require.cache[require.resolve(hook.path)];
         }
-        this.apiHooks = [];
+        this.apiExtensions.hooks = [];
     }
     unregisterEndpoints() {
-        for (const endpoint of this.apiEndpoints) {
+        for (const endpoint of this.apiExtensions.endpoints) {
             delete require.cache[require.resolve(endpoint.path)];
         }
         this.endpointRouter.stack = [];
-        this.apiEndpoints = [];
+        this.apiExtensions.endpoints = [];
     }
 }

package/dist/logger.js

@@ -25,6 +25,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.expressLogger = void 0;
 const pino_1 = __importDefault(require("pino"));
 const pino_http_1 = __importStar(require("pino-http"));
+const get_config_from_env_1 = require("./utils/get-config-from-env");
 const url_1 = require("url");
 const env_1 = __importDefault(require("./env"));
 const pinoOptions = {
@@ -38,9 +39,29 @@ if (env_1.default.LOG_STYLE !== 'raw') {
     pinoOptions.prettyPrint = true;
     pinoOptions.prettifier = require('pino-colada');
 }
-const logger = (0, pino_1.default)(pinoOptions);
+const loggerEnvConfig = (0, get_config_from_env_1.getConfigFromEnv)('LOGGER_', 'LOGGER_HTTP');
+// Expose custom log levels into formatter function
+if (loggerEnvConfig.levels) {
+    const customLogLevels = {};
+    for (const el of loggerEnvConfig.levels.split(',')) {
+        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;
+}
+const logger = (0, pino_1.default)(Object.assign(pinoOptions, loggerEnvConfig));
+const httpLoggerEnvConfig = (0, get_config_from_env_1.getConfigFromEnv)('LOGGER_HTTP', ['LOGGER_HTTP_LOGGER']);
 exports.expressLogger = (0, pino_http_1.default)({
     logger,
+    ...httpLoggerEnvConfig,
 }, {
     serializers: {
         req(request) {

package/dist/middleware/authenticate.js

@@ -27,6 +27,7 @@ const database_1 = __importDefault(require("../database"));
 const env_1 = __importDefault(require("../env"));
 const exceptions_1 = require("../exceptions");
 const async_handler_1 = __importDefault(require("../utils/async-handler"));
+const get_ip_from_req_1 = require("../utils/get-ip-from-req");
 const is_directus_jwt_1 = __importDefault(require("../utils/is-directus-jwt"));
 /**
  * Verify the passed JWT and assign the user ID and role to `req`
@@ -37,7 +38,7 @@ const authenticate = (0, async_handler_1.default)(async (req, res, next) => {
         role: null,
         admin: false,
         app: false,
-        ip: req.ip.startsWith('::ffff:') ? req.ip.substring(7) : req.ip,
+        ip: (0, get_ip_from_req_1.getIPFromReq)(req),
         userAgent: req.get('user-agent'),
     };
     const database = (0, database_1.default)();

package/dist/middleware/extract-token.js

@@ -15,7 +15,7 @@ const extractToken = (req, res, next) => {
     }
     if (req.headers && req.headers.authorization) {
         const parts = req.headers.authorization.split(' ');
-        if (parts.length === 2 && parts[0] === 'Bearer') {
+        if (parts.length === 2 && parts[0].toLowerCase() === 'bearer') {
             token = parts[1];
         }
     }

package/dist/middleware/rate-limiter.js

@@ -9,6 +9,7 @@ const env_1 = __importDefault(require("../env"));
 const exceptions_1 = require("../exceptions");
 const rate_limiter_1 = require("../rate-limiter");
 const async_handler_1 = __importDefault(require("../utils/async-handler"));
+const get_ip_from_req_1 = require("../utils/get-ip-from-req");
 const validate_env_1 = require("../utils/validate-env");
 let checkRateLimit = (req, res, next) => next();
 if (env_1.default.RATE_LIMITER_ENABLED === true) {
@@ -16,7 +17,7 @@ if (env_1.default.RATE_LIMITER_ENABLED === true) {
     exports.rateLimiter = (0, rate_limiter_1.createRateLimiter)();
     checkRateLimit = (0, async_handler_1.default)(async (req, res, next) => {
         try {
-            await exports.rateLimiter.consume(req.ip, 1);
+            await exports.rateLimiter.consume((0, get_ip_from_req_1.getIPFromReq)(req), 1);
         }
         catch (rateLimiterRes) {
             if (rateLimiterRes instanceof Error)