@directus/api 32.1.0 → 32.2.0

package/dist/extensions/lib/sync/sync.js

@@ -0,0 +1,90 @@
+import Queue from 'p-queue';
+import mid from 'node-machine-id';
+import { useEnv } from '@directus/env';
+import { createWriteStream } from 'node:fs';
+import { mkdir, rm } from 'node:fs/promises';
+import { pipeline } from 'node:stream/promises';
+import { dirname, join, relative, resolve, sep } from 'node:path';
+import { getSyncPaths, compareFileMetadata } from './utils.js';
+import { useBus } from '../../../bus/index.js';
+import { SyncFileTracker } from './tracker.js';
+import { useLock } from '../../../lock/index.js';
+import { useLogger } from '../../../logger/index.js';
+import { getStorage } from '../../../storage/index.js';
+import { getExtensionsPath } from '../get-extensions-path.js';
+import { isSynchronizing, setSyncStatus, SyncStatus } from './status.js';
+import { normalizePath } from '@directus/utils';
+export async function syncExtensions(options) {
+    if (options?.skipSync === true)
+        return;
+    const env = useEnv();
+    const lock = useLock();
+    const messenger = useBus();
+    const logger = useLogger();
+    if (options?.forceSync !== true && (await isSynchronizing())) {
+        logger.debug('Extensions are already being synced to this directory from another process.');
+        return;
+    }
+    const machineId = await mid.machineId();
+    const machineKey = `extensions-sync/${machineId}`;
+    const processId = await lock.increment(machineKey);
+    if (processId !== 1) {
+        logger.debug('Extensions are already being synced to this machine from another process.');
+        // Wait until the process that called the lock publishes a message that the syncing is complete
+        return new Promise((resolve) => {
+            messenger.subscribe(machineKey, () => resolve());
+        });
+    }
+    try {
+        logger.debug('Syncing extensions from configured storage location...');
+        // Ensure that the local extensions cache path exists
+        await mkdir(getExtensionsPath(), { recursive: true });
+        await setSyncStatus(SyncStatus.SYNCING);
+        const { localExtensionsPath, remoteExtensionsPath } = getSyncPaths(options?.partialSync);
+        const storage = await getStorage();
+        const disk = storage.location(env['EXTENSIONS_LOCATION']);
+        // check if we are only removing the local directory
+        if (options?.partialSync) {
+            const remoteExists = await disk.exists(normalizePath(join(remoteExtensionsPath, 'package.json')));
+            if (remoteExists === false) {
+                await rm(localExtensionsPath, { recursive: true, force: true });
+                return;
+            }
+        }
+        // Make sure we don't overload the file handles
+        const queue = new Queue({ concurrency: 1000 });
+        // start file tracker
+        const fileTracker = new SyncFileTracker();
+        const localFileCount = await fileTracker.readLocalFiles(localExtensionsPath);
+        const hasLocalFiles = localFileCount > 0;
+        for await (const filepath of disk.list(remoteExtensionsPath)) {
+            // We want files to be stored in the root of `$TEMP_PATH/extensions`, so gotta remove the
+            // extensions path on disk from the start of the file path
+            const relativePath = relative(resolve(sep, remoteExtensionsPath), resolve(sep, filepath));
+            const destinationPath = join(localExtensionsPath, relativePath);
+            await fileTracker.passedFile(relativePath);
+            // No need to check metadata when force is enabled
+            if (options?.forceSync !== true && hasLocalFiles) {
+                const fileUnchanged = await compareFileMetadata(destinationPath, filepath, disk);
+                if (fileUnchanged)
+                    continue;
+            }
+            // Ensure that the directory path exists
+            await mkdir(dirname(destinationPath), { recursive: true });
+            // write remote file to the local filesystem
+            const readStream = await disk.read(filepath);
+            const writeStream = createWriteStream(destinationPath);
+            queue.add(() => pipeline(readStream, writeStream));
+        }
+        // wait for the queue to finish
+        await queue.onIdle();
+        // cleanup dangling local files
+        await fileTracker.cleanup(localExtensionsPath);
+    }
+    finally {
+        // release various locking mechanisms
+        messenger.publish(machineKey, { ready: true });
+        await lock.delete(machineKey);
+        await setSyncStatus(SyncStatus.IDLE);
+    }
+}

package/dist/extensions/lib/sync/tracker.d.ts

@@ -0,0 +1,18 @@
+export declare class SyncFileTracker {
+    private localFiles;
+    private trackedDirs;
+    constructor();
+    /**
+     * Reads all files recusrively in the provided directory
+     * @returns the number of files read
+     */
+    readLocalFiles(localExtensionsPath: string): Promise<number>;
+    /**
+     * Removes a file from the locally tracked files
+     */
+    passedFile(filePath: string): Promise<void>;
+    /**
+     * Removes left over tracked files that were not processed
+     */
+    cleanup(localExtensionsPath: string): Promise<void>;
+}

package/dist/extensions/lib/sync/tracker.js

@@ -0,0 +1,71 @@
+/**
+ * class to help tracking file status between local and remote
+ */
+import { readdir, rm } from 'node:fs/promises';
+import { dirname, join, relative } from 'node:path';
+import { pathDepth } from './utils.js';
+export class SyncFileTracker {
+    localFiles;
+    trackedDirs;
+    constructor() {
+        this.localFiles = new Set();
+        this.trackedDirs = new Set();
+    }
+    /**
+     * Reads all files recusrively in the provided directory
+     * @returns the number of files read
+     */
+    async readLocalFiles(localExtensionsPath) {
+        const entries = await readdir(localExtensionsPath, { recursive: true, withFileTypes: true }).catch(() => {
+            /* path doesnt exist */
+        });
+        if (!entries)
+            return 0;
+        for (const entry of entries) {
+            if (!entry.isFile())
+                continue;
+            const relativePath = join(relative(localExtensionsPath, entry.parentPath), entry.name);
+            this.localFiles.add(relativePath);
+        }
+        return this.localFiles.size;
+    }
+    /**
+     * Removes a file from the locally tracked files
+     */
+    async passedFile(filePath) {
+        this.localFiles.delete(filePath);
+        let currentDir = dirname(filePath);
+        while (currentDir !== '.') {
+            if (this.trackedDirs.has(currentDir))
+                break;
+            this.trackedDirs.add(currentDir);
+            currentDir = dirname(currentDir);
+        }
+    }
+    /**
+     * Removes left over tracked files that were not processed
+     */
+    async cleanup(localExtensionsPath) {
+        const removeDirs = new Set();
+        for (const removeFile of this.localFiles) {
+            if (removeFile === '.status')
+                continue;
+            let currentDir = dirname(removeFile);
+            while (currentDir !== localExtensionsPath && currentDir !== '.') {
+                if (this.trackedDirs.has(currentDir))
+                    break;
+                removeDirs.add(currentDir);
+                currentDir = dirname(currentDir);
+            }
+        }
+        // sort directory by depth so we can remove the highest level directory recursively
+        const removeDirsRecursive = Array.from(removeDirs)
+            .sort((a, b) => pathDepth(b) - pathDepth(a))
+            .filter((d) => !removeDirs.has(dirname(d)));
+        for (const dir of removeDirsRecursive) {
+            const relativePath = join(localExtensionsPath, dir);
+            // removing local folder that does not exist in the remote storage
+            await rm(relativePath, { recursive: true, force: true });
+        }
+    }
+}

package/dist/extensions/lib/sync/utils.d.ts

@@ -0,0 +1,24 @@
+import type { Driver } from '@directus/storage';
+/**
+ * Returns the directory depth of the provided path
+ */
+export declare function pathDepth(path: string): number;
+/**
+ * Reads the size and modified date of a file if it exists
+ */
+export declare function fsStat(path: string): Promise<{
+    size: number;
+    modified: Date;
+} | null>;
+/**
+ * Builds up the local and remote paths to use with syncing
+ */
+export declare function getSyncPaths(partialPath: string | undefined): {
+    localExtensionsPath: string;
+    remoteExtensionsPath: string;
+};
+/**
+ * Retrieve the stats for local and remote files and check if they are the same
+ * Returns false if files are differnt else true
+ */
+export declare function compareFileMetadata(localPath: string, remotePath: string, disk: Driver): Promise<boolean>;

package/dist/extensions/lib/sync/utils.js

@@ -0,0 +1,62 @@
+import { join, relative, resolve, sep } from 'node:path';
+import { stat } from 'node:fs/promises';
+import { getExtensionsPath } from '../get-extensions-path.js';
+import { useEnv } from '@directus/env';
+import { normalizePath } from '@directus/utils';
+/**
+ * Returns the directory depth of the provided path
+ */
+export function pathDepth(path) {
+    let count = 0;
+    for (let i = 0; i < path.length; i++) {
+        if (path[i] === sep)
+            count++;
+    }
+    return count;
+}
+/**
+ * Reads the size and modified date of a file if it exists
+ */
+export async function fsStat(path) {
+    const data = await stat(path, { bigint: false }).catch(() => {
+        /* file not available */
+    });
+    if (!data)
+        return null;
+    return {
+        size: data.size,
+        modified: data.mtime,
+    };
+}
+/**
+ * Builds up the local and remote paths to use with syncing
+ */
+export function getSyncPaths(partialPath) {
+    const env = useEnv();
+    const localRootPath = getExtensionsPath();
+    const remoteRootPath = env['EXTENSIONS_PATH'];
+    if (!partialPath) {
+        return {
+            localExtensionsPath: localRootPath,
+            remoteExtensionsPath: normalizePath(remoteRootPath),
+        };
+    }
+    const resolvedPartialPath = relative(sep, resolve(sep, partialPath));
+    return {
+        localExtensionsPath: join(localRootPath, resolvedPartialPath),
+        remoteExtensionsPath: normalizePath(join(remoteRootPath, resolvedPartialPath)),
+    };
+}
+/**
+ * Retrieve the stats for local and remote files and check if they are the same
+ * Returns false if files are differnt else true
+ */
+export async function compareFileMetadata(localPath, remotePath, disk) {
+    const localStat = await fsStat(localPath).catch(() => { });
+    if (!localStat)
+        return false;
+    const remoteStat = await disk.stat(remotePath).catch(() => { });
+    if (!remoteStat)
+        return false;
+    return remoteStat.modified <= localStat.modified && remoteStat.size === localStat.size;
+}

package/dist/extensions/manager.d.ts

@@ -1,6 +1,7 @@
 import type { Extension, ExtensionManagerOptions } from '@directus/types';
 import { Router } from 'express';
 import type { ReadStream } from 'node:fs';
+import { type ExtensionSyncOptions } from './lib/sync/sync.js';
 export declare class ExtensionManager {
     private options;
     /**
@@ -47,6 +48,10 @@ export declare class ExtensionManager {
      * sequence.
      */
     private reloadQueue;
+    /**
+     * Used to prevent race condition when reading extension data while reloading extensions
+     */
+    private reloadPromise;
     /**
      * Optional file system watcher to auto-reload extensions when the local file system changes
      */
@@ -76,7 +81,7 @@ export declare class ExtensionManager {
      */
     install(versionId: string): Promise<void>;
     uninstall(folder: string): Promise<void>;
-    broadcastReloadNotification(): Promise<void>;
+    broadcastReloadNotification(options?: ExtensionSyncOptions): Promise<void>;
     /**
      * Load all extensions from disk and register them in their respective places
      */
@@ -88,9 +93,8 @@ export declare class ExtensionManager {
     /**
      * Reload all the extensions. Will unload if extensions have already been loaded
      */
-    reload(options?: {
-        forceSync: boolean;
-    }): Promise<unknown>;
+    reload(options?: ExtensionSyncOptions): Promise<unknown>;
+    isReloading(): Promise<void>;
     /**
      * Return the previously generated app extension bundle chunk by name.
      * Providing no name will return the entry bundle.

package/dist/extensions/manager.js

@@ -13,7 +13,7 @@ import ivm from 'isolated-vm';
 import { clone, debounce, isPlainObject } from 'lodash-es';
 import { readFile, readdir } from 'node:fs/promises';
 import os from 'node:os';
-import { dirname, join } from 'node:path';
+import { dirname, join, relative, resolve, sep } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import path from 'path';
 import { rolldown } from 'rolldown';
@@ -37,9 +37,9 @@ import { getSharedDepsMapping } from './lib/get-shared-deps-mapping.js';
 import { getInstallationManager } from './lib/installation/index.js';
 import { generateApiExtensionsSandboxEntrypoint } from './lib/sandbox/generate-api-extensions-sandbox-entrypoint.js';
 import { instantiateSandboxSdk } from './lib/sandbox/sdk/instantiate.js';
-import { syncExtensions } from './lib/sync-extensions.js';
 import { wrapEmbeds } from './lib/wrap-embeds.js';
 import DriverLocal from '@directus/storage-driver-local';
+import { syncExtensions } from './lib/sync/sync.js';
 // Workaround for https://github.com/rollup/plugins/issues/1329
 const virtual = virtualDefault;
 const alias = aliasDefault;
@@ -99,6 +99,10 @@ export class ExtensionManager {
      * sequence.
      */
     reloadQueue = new JobQueue();
+    /**
+     * Used to prevent race condition when reading extension data while reloading extensions
+     */
+    reloadPromise = Promise.resolve();
     /**
      * Optional file system watcher to auto-reload extensions when the local file system changes
      */
@@ -148,7 +152,7 @@ export class ExtensionManager {
             await this.closeWatcher();
         }
         if (!this.isLoaded) {
-            await this.load();
+            await this.load({ forceSync: true });
             if (this.extensions.length > 0) {
                 logger.info(`Loaded extensions: ${this.extensions.map((ext) => ext.name).join(', ')}`);
             }
@@ -160,7 +164,13 @@ export class ExtensionManager {
             // Ignore requests for reloading that were published by the current process
             if (isPlainObject(payload) && 'origin' in payload && payload['origin'] === this.processId)
                 return;
-            this.reload();
+            // Reload extensions with event options
+            const options = {};
+            if (typeof payload['forceSync'] === 'boolean')
+                options.forceSync = payload['forceSync'];
+            if (typeof payload['partialSync'] === 'string')
+                options.partialSync = payload['partialSync'];
+            this.reload(options);
         });
     }
     /**
@@ -169,27 +179,31 @@ export class ExtensionManager {
     async install(versionId) {
         const logger = useLogger();
         await this.installationManager.install(versionId);
-        await this.reload({ forceSync: true });
+        const resolvedFolder = relative(sep, resolve(sep, versionId));
+        const syncFolder = join('.registry', resolvedFolder);
+        await this.broadcastReloadNotification({ partialSync: syncFolder });
+        await this.reload({ skipSync: true });
         emitter.emitAction('extensions.installed', {
             extensions: this.extensions,
             versionId,
         });
         logger.info(`Installed extension: ${versionId}`);
-        await this.broadcastReloadNotification();
     }
     async uninstall(folder) {
         const logger = useLogger();
         await this.installationManager.uninstall(folder);
-        await this.reload({ forceSync: true });
+        const resolvedFolder = relative(sep, resolve(sep, folder));
+        const syncFolder = join('.registry', resolvedFolder);
+        await this.broadcastReloadNotification({ partialSync: syncFolder });
+        await this.reload({ skipSync: true });
         emitter.emitAction('extensions.uninstalled', {
             extensions: this.extensions,
             folder,
         });
         logger.info(`Uninstalled extension: ${folder}`);
-        await this.broadcastReloadNotification();
     }
-    async broadcastReloadNotification() {
-        await this.messenger.publish(this.reloadChannel, { origin: this.processId });
+    async broadcastReloadNotification(options) {
+        await this.messenger.publish(this.reloadChannel, { ...options, origin: this.processId });
     }
     /**
      * Load all extensions from disk and register them in their respective places
@@ -198,7 +212,7 @@ export class ExtensionManager {
         const logger = useLogger();
         if (env['EXTENSIONS_LOCATION']) {
             try {
-                await syncExtensions({ force: options?.forceSync ?? false });
+                await syncExtensions(options);
             }
             catch (error) {
                 logger.error(`Failed to sync extensions`);
@@ -250,7 +264,7 @@ export class ExtensionManager {
         const logger = useLogger();
         let resolve;
         let reject;
-        const promise = new Promise((res, rej) => {
+        this.reloadPromise = new Promise((res, rej) => {
             resolve = res;
             reject = rej;
         });
@@ -283,7 +297,10 @@ export class ExtensionManager {
                 reject(new Error('Extensions have to be loaded before they can be reloaded'));
             }
         });
-        return promise;
+        return this.reloadPromise;
+    }
+    isReloading() {
+        return this.reloadPromise;
     }
     /**
      * Return the previously generated app extension bundle chunk by name.

package/dist/middleware/respond.js

@@ -1,4 +1,5 @@
 import { useEnv } from '@directus/env';
+import { getDateTimeFormatted } from '@directus/utils';
 import { parse as parseBytesConfiguration } from 'bytes';
 import { getCache, setCacheValue } from '../cache.js';
 import getDatabase from '../database/index.js';
@@ -7,7 +8,6 @@ import { ExportService } from '../services/import-export.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 { getDateFormatted } from '../utils/get-date-formatted.js';
 import { getMilliseconds } from '../utils/get-milliseconds.js';
 import { stringByteSize } from '../utils/get-string-byte-size.js';
 import { permissionsCacheable } from '../utils/permissions-cacheable.js';
@@ -58,7 +58,7 @@ export const respond = asyncHandler(async (req, res) => {
         else {
             filename += 'Export';
         }
-        filename += ' ' + getDateFormatted();
+        filename += ' ' + getDateTimeFormatted();
         if (req.sanitizedQuery.export === 'json') {
             res.attachment(`${filename}.json`);
             res.set('Content-Type', 'application/json');

package/dist/permissions/lib/fetch-policies.d.ts

@@ -7,7 +7,7 @@ export interface AccessRow {
     };
     role: string | null;
 }
-export declare const fetchPolicies: typeof _fetchPolicies;
+export declare const fetchPolicies: (args_0: Pick<Accountability, "user" | "roles" | "ip">, context: Context) => Promise<string[]>;
 /**
  * Fetch the policies associated with the current user accountability
  */

package/dist/permissions/lib/fetch-roles-tree.d.ts

@@ -1,3 +1,6 @@
-import type { Knex } from 'knex';
-export declare const fetchRolesTree: typeof _fetchRolesTree;
-export declare function _fetchRolesTree(start: string | null, knex: Knex): Promise<string[]>;
+/**
+ * Fetches the roles tree starting from a specific role.
+ */
+export declare const fetchRolesTree: (start: string | null, context: {
+    knex: import("knex").Knex;
+}) => Promise<string[]>;

package/dist/permissions/lib/fetch-roles-tree.js

@@ -1,28 +1,6 @@
+import { fetchRolesTree as _fetchRolesTree } from '@directus/utils/node';
 import { withCache } from '../utils/with-cache.js';
-export const fetchRolesTree = withCache('roles-tree', _fetchRolesTree);
-export async function _fetchRolesTree(start, knex) {
-    if (!start)
-        return [];
-    let parent = start;
-    const roles = [];
-    while (parent) {
-        const role = await knex
-            .select('id', 'parent')
-            .from('directus_roles')
-            .where({ id: parent })
-            .first();
-        if (!role) {
-            break;
-        }
-        roles.push(role.id);
-        // Prevent infinite recursion loops
-        if (role.parent && roles.includes(role.parent) === true) {
-            roles.reverse();
-            const rolesStr = roles.map((role) => `"${role}"`).join('->');
-            throw new Error(`Recursion encountered: role "${role.id}" already exists in tree path ${rolesStr}`);
-        }
-        parent = role.parent;
-    }
-    roles.reverse();
-    return roles;
-}
+/**
+ * Fetches the roles tree starting from a specific role.
+ */
+export const fetchRolesTree = withCache('roles-tree', _fetchRolesTree, (start) => ({ start }));

package/dist/permissions/modules/fetch-global-access/fetch-global-access.d.ts

@@ -1,10 +1,12 @@
-import type { Accountability } from '@directus/types';
+import type { Accountability, GlobalAccess } from '@directus/types';
 import type { Knex } from 'knex';
-import type { GlobalAccess } from './types.js';
-export declare const fetchGlobalAccess: typeof _fetchGlobalAccess;
+interface FetchGlobalAccessContext {
+    knex: Knex;
+    ip?: Accountability['ip'];
+}
+export declare const fetchGlobalAccess: (accountability: Pick<Accountability, "user" | "roles" | "ip">, context: FetchGlobalAccessContext) => Promise<GlobalAccess>;
 /**
- * Fetch the global access (eg admin/app access) rules for the given roles, or roles+user combination
- *
- * Will fetch roles and user info separately so they can be cached and reused individually
+ * Re-implements fetchGlobalAccess to add caching, fetches roles and user info separately so they can be cached and reused individually
  */
-export declare function _fetchGlobalAccess(accountability: Pick<Accountability, 'user' | 'roles' | 'ip'>, knex: Knex): Promise<GlobalAccess>;
+export declare function _fetchGlobalAccess(accountability: Pick<Accountability, 'user' | 'roles' | 'ip'>, context: FetchGlobalAccessContext): Promise<GlobalAccess>;
+export {};

package/dist/permissions/modules/fetch-global-access/fetch-global-access.js

@@ -1,20 +1,28 @@
+import { fetchGlobalAccessForRoles as _fetchGlobalAccessForRoles, fetchGlobalAccessForUser as _fetchGlobalAccessForUser, } from '@directus/utils/node';
 import { withCache } from '../../utils/with-cache.js';
-import { fetchGlobalAccessForRoles } from './lib/fetch-global-access-for-roles.js';
-import { fetchGlobalAccessForUser } from './lib/fetch-global-access-for-user.js';
-export const fetchGlobalAccess = withCache('global-access', _fetchGlobalAccess, ({ user, roles, ip }) => ({
+export const fetchGlobalAccess = withCache('global-access', _fetchGlobalAccess, ({ user, roles }, { ip }) => ({
     user,
     roles,
     ip,
 }));
+const fetchGlobalAccessForRoles = withCache('global-access-roles', _fetchGlobalAccessForRoles, (roles, { ip }) => ({
+    roles,
+    ip,
+}));
+const fetchGlobalAccessForUser = withCache('global-access-user', _fetchGlobalAccessForUser, (user, { ip }) => ({
+    user,
+    ip,
+}));
 /**
- * Fetch the global access (eg admin/app access) rules for the given roles, or roles+user combination
- *
- * Will fetch roles and user info separately so they can be cached and reused individually
+ * Re-implements fetchGlobalAccess to add caching, fetches roles and user info separately so they can be cached and reused individually
  */
-export async function _fetchGlobalAccess(accountability, knex) {
-    const access = await fetchGlobalAccessForRoles(accountability, knex);
+export async function _fetchGlobalAccess(accountability, context) {
+    const access = await fetchGlobalAccessForRoles(accountability.roles, { knex: context.knex, ip: accountability.ip });
     if (accountability.user !== undefined) {
-        const userAccess = await fetchGlobalAccessForUser(accountability, knex);
+        const userAccess = await fetchGlobalAccessForUser(accountability.user, {
+            knex: context.knex,
+            ip: accountability.ip,
+        });
         // If app/admin is already true, keep it true
         access.app ||= userAccess.app;
         access.admin ||= userAccess.admin;

package/dist/permissions/modules/fetch-policies-ip-access/fetch-policies-ip-access.d.ts

@@ -1,4 +1,4 @@
 import type { Accountability } from '@directus/types';
 import type { Knex } from 'knex';
-export declare const fetchPoliciesIpAccess: typeof _fetchPoliciesIpAccess;
+export declare const fetchPoliciesIpAccess: (accountability: Pick<Accountability, "user" | "roles">, knex: Knex<any, any[]>) => Promise<string[][]>;
 export declare function _fetchPoliciesIpAccess(accountability: Pick<Accountability, 'user' | 'roles'>, knex: Knex): Promise<string[][]>;

package/dist/permissions/utils/fetch-raw-permissions.d.ts

@@ -1,6 +1,6 @@
 import type { Accountability, Permission, PermissionsAction } from '@directus/types';
 import type { Context } from '../types.js';
-export declare const fetchRawPermissions: typeof _fetchRawPermissions;
+export declare const fetchRawPermissions: (options: FetchRawPermissionsOptions, context: Context) => Promise<Permission[]>;
 export interface FetchRawPermissionsOptions {
     action?: PermissionsAction;
     policies: string[];

package/dist/permissions/utils/fetch-share-info.d.ts

@@ -8,5 +8,5 @@ export interface ShareInfo {
         role: string;
     };
 }
-export declare const fetchShareInfo: typeof _fetchShareInfo;
+export declare const fetchShareInfo: (shareId: string, context: AbstractServiceOptions) => Promise<ShareInfo>;
 export declare function _fetchShareInfo(shareId: string, context: AbstractServiceOptions): Promise<ShareInfo>;

package/dist/permissions/utils/fetch-share-info.js

@@ -1,5 +1,5 @@
 import { withCache } from './with-cache.js';
-export const fetchShareInfo = withCache('share-info', _fetchShareInfo);
+export const fetchShareInfo = withCache('share-info', _fetchShareInfo, (shareId) => ({ shareId }));
 export async function _fetchShareInfo(shareId, context) {
     const { SharesService } = await import('../../services/shares.js');
     const sharesService = new SharesService(context);

package/dist/permissions/utils/filter-policies-by-ip.js

@@ -1,4 +1,4 @@
-import { ipInNetworks } from '../../utils/ip-in-networks.js';
+import { ipInNetworks } from '@directus/utils/node';
 export function filterPoliciesByIp(policies, ip) {
     return policies.filter(({ policy }) => {
         // Keep policies that don't have an ip address allow list configured

package/dist/permissions/utils/get-permissions-for-share.js

@@ -1,13 +1,13 @@
 import { schemaPermissions } from '@directus/system-data';
 import { set, uniq } from 'lodash-es';
-import { fetchAllowedFieldMap } from '../modules/fetch-allowed-field-map/fetch-allowed-field-map.js';
-import { fetchShareInfo } from './fetch-share-info.js';
-import { mergePermissions } from './merge-permissions.js';
+import { reduceSchema } from '../../utils/reduce-schema.js';
 import { fetchPermissions } from '../lib/fetch-permissions.js';
 import { fetchPolicies } from '../lib/fetch-policies.js';
 import { fetchRolesTree } from '../lib/fetch-roles-tree.js';
-import { reduceSchema } from '../../utils/reduce-schema.js';
+import { fetchAllowedFieldMap } from '../modules/fetch-allowed-field-map/fetch-allowed-field-map.js';
 import { fetchGlobalAccess } from '../modules/fetch-global-access/fetch-global-access.js';
+import { fetchShareInfo } from './fetch-share-info.js';
+import { mergePermissions } from './merge-permissions.js';
 export async function getPermissionsForShare(accountability, collections, context) {
     const defaults = {
         action: 'read',
@@ -22,7 +22,7 @@ export async function getPermissionsForShare(accountability, collections, contex
     const userAccountability = {
         user: user_created.id,
         role: user_created.role,
-        roles: await fetchRolesTree(user_created.role, context.knex),
+        roles: await fetchRolesTree(user_created.role, { knex: context.knex }),
         admin: false,
         app: false,
         ip: accountability.ip,
@@ -31,14 +31,14 @@ export async function getPermissionsForShare(accountability, collections, contex
     const shareAccountability = {
         user: null,
         role: role,
-        roles: await fetchRolesTree(role, context.knex),
+        roles: await fetchRolesTree(role, { knex: context.knex }),
         admin: false,
         app: false,
         ip: accountability.ip,
     };
     const [{ admin: shareIsAdmin }, { admin: userIsAdmin }, userPermissions, sharePermissions, shareFieldMap, userFieldMap,] = await Promise.all([
-        fetchGlobalAccess(shareAccountability, context.knex),
-        fetchGlobalAccess(userAccountability, context.knex),
+        fetchGlobalAccess(shareAccountability, { knex: context.knex }),
+        fetchGlobalAccess(userAccountability, { knex: context.knex }),
         getPermissionsForAccountability(userAccountability, context),
         getPermissionsForAccountability(shareAccountability, context),
         fetchAllowedFieldMap({