directus 9.21.2 → 9.22.0

package/dist/services/permissions.js

@@ -60,16 +60,6 @@ class PermissionsService extends items_1.ItemsService {
         await (0, cache_1.clearSystemCache)();
         return res;
     }
-    async updateByQuery(query, data, opts) {
-        const res = await super.updateByQuery(query, data, opts);
-        await (0, cache_1.clearSystemCache)();
-        return res;
-    }
-    async updateOne(key, data, opts) {
-        const res = await super.updateOne(key, data, opts);
-        await (0, cache_1.clearSystemCache)();
-        return res;
-    }
     async updateBatch(data, opts) {
         const res = await super.updateBatch(data, opts);
         await (0, cache_1.clearSystemCache)();
@@ -80,26 +70,11 @@ class PermissionsService extends items_1.ItemsService {
         await (0, cache_1.clearSystemCache)();
         return res;
     }
-    async upsertOne(payload, opts) {
-        const res = await super.upsertOne(payload, opts);
-        await (0, cache_1.clearSystemCache)();
-        return res;
-    }
     async upsertMany(payloads, opts) {
         const res = await super.upsertMany(payloads, opts);
         await (0, cache_1.clearSystemCache)();
         return res;
     }
-    async deleteByQuery(query, opts) {
-        const res = await super.deleteByQuery(query, opts);
-        await (0, cache_1.clearSystemCache)();
-        return res;
-    }
-    async deleteOne(key, opts) {
-        const res = await super.deleteOne(key, opts);
-        await (0, cache_1.clearSystemCache)();
-        return res;
-    }
     async deleteMany(keys, opts) {
         const res = await super.deleteMany(keys, opts);
         await (0, cache_1.clearSystemCache)();

package/dist/services/permissions.test.d.ts

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

package/dist/services/roles.js

@@ -56,9 +56,6 @@ class RolesService extends items_1.ItemsService {
         return;
     }
     async updateOne(key, data, opts) {
-        if ('admin_access' in data && data.admin_access === false) {
-            await this.checkForOtherAdminRoles([key]);
-        }
         if ('users' in data) {
             await this.checkForOtherAdminUsers(key, data.users);
         }

package/dist/services/roles.test.d.ts

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

package/dist/services/server.js

@@ -28,7 +28,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ServerService = void 0;
 const lodash_1 = require("lodash");
-const nanoid_1 = require("nanoid");
 const os_1 = __importDefault(require("os"));
 const perf_hooks_1 = require("perf_hooks");
 // @ts-ignore
@@ -38,11 +37,12 @@ const database_1 = __importStar(require("../database"));
 const env_1 = __importDefault(require("../env"));
 const logger_1 = __importDefault(require("../logger"));
 const rate_limiter_1 = require("../middleware/rate-limiter");
-const storage_1 = __importDefault(require("../storage"));
+const storage_1 = require("../storage");
 const utils_1 = require("@directus/shared/utils");
 const mailer_1 = __importDefault(require("../mailer"));
 const settings_1 = require("./settings");
 const get_os_info_1 = require("../utils/get-os-info");
+const node_stream_1 = require("node:stream");
 class ServerService {
     constructor(options) {
         this.knex = options.knex || (0, database_1.default)();
@@ -101,7 +101,8 @@ class ServerService {
     }
     async health() {
         var _a;
-        const checkID = (0, nanoid_1.nanoid)(5);
+        const { nanoid } = await import('nanoid');
+        const checkID = nanoid(5);
         const data = {
             status: 'ok',
             releaseId: package_json_1.version,
@@ -246,9 +247,10 @@ class ServerService {
             return checks;
         }
         async function testStorage() {
+            const storage = await (0, storage_1.getStorage)();
             const checks = {};
             for (const location of (0, utils_1.toArray)(env_1.default.STORAGE_LOCATIONS)) {
-                const disk = storage_1.default.disk(location);
+                const disk = storage.location(location);
                 const envThresholdKey = `STORAGE_${location}_HEALTHCHECK_THRESHOLD`.toUpperCase();
                 checks[`storage:${location}:responseTime`] = [
                     {
@@ -261,8 +263,8 @@ class ServerService {
                 ];
                 const startTime = perf_hooks_1.performance.now();
                 try {
-                    await disk.put(`health-${checkID}`, 'check');
-                    await disk.get(`health-${checkID}`);
+                    await disk.write(`health-${checkID}`, node_stream_1.Readable.from(['check']));
+                    await disk.read(`health-${checkID}`);
                     await disk.delete(`health-${checkID}`);
                 }
                 catch (err) {

package/dist/services/shares.js

@@ -10,7 +10,6 @@ const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
 const ms_1 = __importDefault(require("ms"));
 const exceptions_1 = require("../exceptions");
 const env_1 = __importDefault(require("../env"));
-const nanoid_1 = require("nanoid");
 const authorization_1 = require("./authorization");
 const users_1 = require("./users");
 const mail_1 = require("./mail");
@@ -32,6 +31,7 @@ class SharesService extends items_1.ItemsService {
     }
     async login(payload) {
         var _a, _b, _c;
+        const { nanoid } = await import('nanoid');
         const record = await this.knex
             .select({
             share_id: 'id',
@@ -79,7 +79,7 @@ class SharesService extends items_1.ItemsService {
             expiresIn: env_1.default.ACCESS_TOKEN_TTL,
             issuer: 'directus',
         });
-        const refreshToken = (0, nanoid_1.nanoid)(64);
+        const refreshToken = nanoid(64);
         const refreshTokenExpiration = new Date(Date.now() + (0, ms_1.default)(env_1.default.REFRESH_TOKEN_TTL));
         await this.knex('directus_sessions').insert({
             token: refreshToken,

package/dist/services/specifications.js

@@ -4,7 +4,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SpecificationService = void 0;
-const format_title_1 = __importDefault(require("@directus/format-title"));
 const specs_1 = __importDefault(require("@directus/specs"));
 const lodash_1 = require("lodash");
 // @ts-ignore
@@ -16,6 +15,9 @@ const collections_1 = require("./collections");
 const fields_1 = require("./fields");
 const graphql_1 = require("./graphql");
 const relations_1 = require("./relations");
+const constants_1 = require("../constants");
+// @ts-ignore
+const format_title_1 = __importDefault(require("@directus/format-title"));
 class SpecificationService {
     constructor(options) {
         this.accountability = options.accountability || null;
@@ -330,10 +332,19 @@ class OASSpecsService {
         return paths;
     }
     async generateComponents(collections, fields, relations, tags) {
+        var _a;
         let components = (0, lodash_1.cloneDeep)(specs_1.default.components);
         if (!components)
             components = {};
         components.schemas = {};
+        // Always includes the schemas with these names
+        if (((_a = specs_1.default.components) === null || _a === void 0 ? void 0 : _a.schemas) !== null) {
+            for (const schemaName of constants_1.OAS_REQUIRED_SCHEMAS) {
+                if (specs_1.default.components.schemas[schemaName] !== null) {
+                    components.schemas[schemaName] = (0, lodash_1.cloneDeep)(specs_1.default.components.schemas[schemaName]);
+                }
+            }
+        }
         if (!tags)
             return;
         for (const collection of collections) {

package/dist/services/webhooks.d.ts

@@ -6,8 +6,6 @@ export declare class WebhooksService extends ItemsService<Webhook> {
     constructor(options: AbstractServiceOptions);
     createOne(data: Partial<Item>, opts?: MutationOptions): Promise<PrimaryKey>;
     createMany(data: Partial<Item>[], opts?: MutationOptions): Promise<PrimaryKey[]>;
-    updateOne(key: PrimaryKey, data: Partial<Item>, opts?: MutationOptions): Promise<PrimaryKey>;
     updateMany(keys: PrimaryKey[], data: Partial<Item>, opts?: MutationOptions): Promise<PrimaryKey[]>;
-    deleteOne(key: PrimaryKey, opts?: MutationOptions): Promise<PrimaryKey>;
     deleteMany(keys: PrimaryKey[], opts?: MutationOptions): Promise<PrimaryKey[]>;
 }

package/dist/services/webhooks.js

@@ -18,21 +18,11 @@ class WebhooksService extends items_1.ItemsService {
         this.messenger.publish('webhooks', { type: 'reload' });
         return result;
     }
-    async updateOne(key, data, opts) {
-        const result = await super.updateOne(key, data, opts);
-        this.messenger.publish('webhooks', { type: 'reload' });
-        return result;
-    }
     async updateMany(keys, data, opts) {
         const result = await super.updateMany(keys, data, opts);
         this.messenger.publish('webhooks', { type: 'reload' });
         return result;
     }
-    async deleteOne(key, opts) {
-        const result = await super.deleteOne(key, opts);
-        this.messenger.publish('webhooks', { type: 'reload' });
-        return result;
-    }
     async deleteMany(keys, opts) {
         const result = await super.deleteMany(keys, opts);
         this.messenger.publish('webhooks', { type: 'reload' });

package/dist/services/webhooks.test.d.ts

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

package/dist/storage/get-storage-driver.d.ts

@@ -0,0 +1,3 @@
+import type { Driver } from '@directus/storage';
+export declare const _aliasMap: Record<string, string>;
+export declare const getStorageDriver: (driverName: string) => Promise<typeof Driver>;

package/dist/storage/get-storage-driver.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStorageDriver = exports._aliasMap = void 0;
+exports._aliasMap = {
+    local: '@directus/storage-driver-local',
+    s3: '@directus/storage-driver-s3',
+    gcs: '@directus/storage-driver-gcs',
+    azure: '@directus/storage-driver-azure',
+    cloudinary: '@directus/storage-driver-cloudinary',
+};
+const getStorageDriver = async (driverName) => {
+    if (driverName in exports._aliasMap) {
+        driverName = exports._aliasMap[driverName];
+    }
+    else {
+        throw new Error(`Driver "${driverName}" doesn't exist.`);
+    }
+    return (await import(driverName)).default;
+};
+exports.getStorageDriver = getStorageDriver;

package/dist/storage/get-storage-driver.test.d.ts

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

package/dist/storage/index.d.ts

@@ -0,0 +1,5 @@
+import type { StorageManager } from '@directus/storage';
+export declare const _cache: {
+    storage: any | null;
+};
+export declare const getStorage: () => Promise<StorageManager>;

package/dist/storage/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStorage = exports._cache = void 0;
+const validate_env_1 = require("../utils/validate-env");
+const register_drivers_1 = require("./register-drivers");
+const register_locations_1 = require("./register-locations");
+exports._cache = {
+    storage: null,
+};
+const getStorage = async () => {
+    if (exports._cache.storage)
+        return exports._cache.storage;
+    const { StorageManager } = await import('@directus/storage');
+    (0, validate_env_1.validateEnv)(['STORAGE_LOCATIONS']);
+    exports._cache.storage = new StorageManager();
+    await (0, register_drivers_1.registerDrivers)(exports._cache.storage);
+    await (0, register_locations_1.registerLocations)(exports._cache.storage);
+    return exports._cache.storage;
+};
+exports.getStorage = getStorage;

package/dist/storage/index.test.d.ts

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

package/dist/storage/register-drivers.d.ts

@@ -0,0 +1,2 @@
+import type { StorageManager } from '@directus/storage';
+export declare const registerDrivers: (storage: StorageManager) => Promise<void>;

package/dist/storage/register-drivers.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerDrivers = void 0;
+const env_1 = require("../env");
+const get_storage_driver_1 = require("./get-storage-driver");
+const registerDrivers = async (storage) => {
+    const env = (0, env_1.getEnv)();
+    const usedDrivers = [];
+    for (const [key, value] of Object.entries(env)) {
+        if ((key.startsWith('STORAGE_') && key.endsWith('_DRIVER')) === false)
+            continue;
+        if (value && usedDrivers.includes(value) === false)
+            usedDrivers.push(value);
+    }
+    for (const driverName of usedDrivers) {
+        const storageDriver = await (0, get_storage_driver_1.getStorageDriver)(driverName);
+        if (storageDriver) {
+            storage.registerDriver(driverName, storageDriver);
+        }
+    }
+};
+exports.registerDrivers = registerDrivers;

package/dist/storage/register-drivers.test.d.ts

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

package/dist/storage/register-locations.d.ts

@@ -0,0 +1,2 @@
+import type { StorageManager } from '@directus/storage';
+export declare const registerLocations: (storage: StorageManager) => Promise<void>;

package/dist/storage/register-locations.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerLocations = void 0;
+const utils_1 = require("@directus/shared/utils");
+const env_1 = require("../env");
+const get_config_from_env_1 = require("../utils/get-config-from-env");
+const registerLocations = async (storage) => {
+    const env = (0, env_1.getEnv)();
+    const locations = (0, utils_1.toArray)(env.STORAGE_LOCATIONS);
+    locations.forEach((location) => {
+        location = location.trim();
+        const driverConfig = (0, get_config_from_env_1.getConfigFromEnv)(`STORAGE_${location.toUpperCase()}_`);
+        const { driver, ...options } = driverConfig;
+        storage.registerLocation(location, { driver, options });
+    });
+};
+exports.registerLocations = registerLocations;

package/dist/storage/register-locations.test.d.ts

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

package/dist/utils/apply-query.d.ts

@@ -1,10 +1,34 @@
 import { Aggregate, Filter, Query, SchemaOverview } from '@directus/shared/types';
 import { Knex } from 'knex';
+import { AliasMap } from './get-column-path';
+export declare const generateAlias: () => string;
 /**
  * Apply the Query to a given Knex query builder instance
  */
-export default function applyQuery(knex: Knex, collection: string, dbQuery: Knex.QueryBuilder, query: Query, schema: SchemaOverview, subQuery?: boolean): Knex.QueryBuilder;
-export declare function applySort(knex: Knex, schema: SchemaOverview, rootQuery: Knex.QueryBuilder, rootSort: string[], collection: string, subQuery?: boolean): void;
-export declare function applyFilter(knex: Knex, schema: SchemaOverview, rootQuery: Knex.QueryBuilder, rootFilter: Filter, collection: string, subQuery?: boolean): Knex.QueryBuilder<any, any>;
+export default function applyQuery(knex: Knex, collection: string, dbQuery: Knex.QueryBuilder, query: Query, schema: SchemaOverview, options?: {
+    aliasMap?: AliasMap;
+    isInnerQuery?: boolean;
+    hasMultiRelationalSort?: boolean;
+}): {
+    query: Knex.QueryBuilder<any, any>;
+    hasMultiRelationalFilter: boolean;
+};
+export type ColumnSortRecord = {
+    order: 'asc' | 'desc';
+    column: string;
+};
+export declare function applySort(knex: Knex, schema: SchemaOverview, rootQuery: Knex.QueryBuilder, rootSort: string[], collection: string, aliasMap: AliasMap, returnRecords?: boolean): {
+    sortRecords: {
+        order: "asc" | "desc";
+        column: any;
+    }[];
+    hasMultiRelationalSort: boolean;
+} | undefined;
+export declare function applyLimit(rootQuery: Knex.QueryBuilder, limit: any): void;
+export declare function applyOffset(knex: Knex, rootQuery: Knex.QueryBuilder, offset: any): void;
+export declare function applyFilter(knex: Knex, schema: SchemaOverview, rootQuery: Knex.QueryBuilder, rootFilter: Filter, collection: string, aliasMap: AliasMap): {
+    query: Knex.QueryBuilder<any, any>;
+    hasMultiRelationalFilter: boolean;
+};
 export declare function applySearch(schema: SchemaOverview, dbQuery: Knex.QueryBuilder, searchQuery: string, collection: string): Promise<void>;
 export declare function applyAggregate(dbQuery: Knex.QueryBuilder, aggregate: Aggregate, collection: string): void;