@directus/api 18.2.1 → 19.0.1

package/dist/services/items.js

@@ -1,6 +1,7 @@
 import { Action } from '@directus/constants';
 import { useEnv } from '@directus/env';
 import { ForbiddenError, InvalidPayloadError } from '@directus/errors';
+import { isSystemCollection } from '@directus/system-data';
 import { assign, clone, cloneDeep, omit, pick, without } from 'lodash-es';
 import { getCache } from '../cache.js';
 import { translateDatabaseError } from '../database/errors/translate.js';
@@ -10,10 +11,10 @@ import runAST from '../database/run-ast.js';
 import emitter from '../emitter.js';
 import getASTFromQuery from '../utils/get-ast-from-query.js';
 import { shouldClearCache } from '../utils/should-clear-cache.js';
+import { transaction } from '../utils/transaction.js';
 import { validateKeys } from '../utils/validate-keys.js';
 import { AuthorizationService } from './authorization.js';
 import { PayloadService } from './payload.js';
-import { isSystemCollection } from '@directus/system-data';
 const env = useEnv();
 export class ItemsService {
     collection;
@@ -82,7 +83,7 @@ export class ItemsService {
         // changes in the DB if any of the parts contained within throws an error. This also means
         // that any errors thrown in any nested relational changes will bubble up and cancel the whole
         // update tree
-        const primaryKey = await this.knex.transaction(async (trx) => {
+        const primaryKey = await transaction(this.knex, async (trx) => {
             // We're creating new services instances so they can use the transaction as their Knex interface
             const payloadService = new PayloadService(this.collection, {
                 accountability: this.accountability,
@@ -255,11 +256,11 @@ export class ItemsService {
     async createMany(data, opts = {}) {
         if (!opts.mutationTracker)
             opts.mutationTracker = this.createMutationTracker();
-        const { primaryKeys, nestedActionEvents } = await this.knex.transaction(async (trx) => {
+        const { primaryKeys, nestedActionEvents } = await transaction(this.knex, async (knex) => {
             const service = new ItemsService(this.collection, {
                 accountability: this.accountability,
                 schema: this.schema,
-                knex: trx,
+                knex: knex,
             });
             const primaryKeys = [];
             const nestedActionEvents = [];
@@ -418,7 +419,7 @@ export class ItemsService {
         const primaryKeyField = this.schema.collections[this.collection].primary;
         const keys = [];
         try {
-            await this.knex.transaction(async (trx) => {
+            await transaction(this.knex, async (trx) => {
                 const service = new ItemsService(this.collection, {
                     accountability: this.accountability,
                     knex: trx,
@@ -488,7 +489,7 @@ export class ItemsService {
         if (opts.preMutationError) {
             throw opts.preMutationError;
         }
-        await this.knex.transaction(async (trx) => {
+        await transaction(this.knex, async (trx) => {
             const payloadService = new PayloadService(this.collection, {
                 accountability: this.accountability,
                 knex: trx,
@@ -629,7 +630,7 @@ export class ItemsService {
     async upsertMany(payloads, opts = {}) {
         if (!opts.mutationTracker)
             opts.mutationTracker = this.createMutationTracker();
-        const primaryKeys = await this.knex.transaction(async (trx) => {
+        const primaryKeys = await transaction(this.knex, async (trx) => {
             const service = new ItemsService(this.collection, {
                 accountability: this.accountability,
                 schema: this.schema,
@@ -697,7 +698,7 @@ export class ItemsService {
                 accountability: this.accountability,
             });
         }
-        await this.knex.transaction(async (trx) => {
+        await transaction(this.knex, async (trx) => {
             await trx(this.collection).whereIn(primaryKeyField, keys).delete();
             if (this.accountability && this.schema.collections[this.collection].accountability !== null) {
                 const activityService = new ActivityService({

package/dist/services/notifications.d.ts

@@ -1,5 +1,5 @@
-import type { Notification } from '@directus/types';
-import type { AbstractServiceOptions, MutationOptions, PrimaryKey } from '../types/index.js';
+import type { Notification, PrimaryKey } from '@directus/types';
+import type { AbstractServiceOptions, MutationOptions } from '../types/index.js';
 import { ItemsService } from './items.js';
 import { MailService } from './mail/index.js';
 import { UsersService } from './users.js';

package/dist/services/operations.d.ts

@@ -1,5 +1,5 @@
-import type { OperationRaw } from '@directus/types';
-import type { AbstractServiceOptions, Item, MutationOptions, PrimaryKey } from '../types/index.js';
+import type { Item, OperationRaw, PrimaryKey } from '@directus/types';
+import type { AbstractServiceOptions, MutationOptions } from '../types/index.js';
 import { ItemsService } from './items.js';
 export declare class OperationsService extends ItemsService<OperationRaw> {
     constructor(options: AbstractServiceOptions);

package/dist/services/payload.d.ts

@@ -1,7 +1,7 @@
-import type { Accountability, SchemaOverview } from '@directus/types';
+import type { Accountability, Item, PrimaryKey, SchemaOverview } from '@directus/types';
 import type { Knex } from 'knex';
 import type { Helpers } from '../database/helpers/index.js';
-import type { AbstractServiceOptions, ActionEventParams, Item, MutationOptions, PrimaryKey } from '../types/index.js';
+import type { AbstractServiceOptions, ActionEventParams, MutationOptions } from '../types/index.js';
 type Action = 'create' | 'read' | 'update';
 type Transformers = {
     [type: string]: (context: {

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

@@ -1,6 +1,6 @@
-import type { ItemPermissions, PermissionsAction, Query } from '@directus/types';
+import type { Item, ItemPermissions, PermissionsAction, PrimaryKey, Query } from '@directus/types';
 import type Keyv from 'keyv';
-import type { AbstractServiceOptions, Item, MutationOptions, PrimaryKey } from '../../types/index.js';
+import type { AbstractServiceOptions, MutationOptions } from '../../types/index.js';
 import type { QueryOptions } from '../items.js';
 import { ItemsService } from '../items.js';
 export declare class PermissionsService extends ItemsService {

package/dist/services/relations.js

@@ -8,6 +8,7 @@ import getDatabase, { getSchemaInspector } from '../database/index.js';
 import emitter from '../emitter.js';
 import { getDefaultIndexName } from '../utils/get-default-index-name.js';
 import { getSchema } from '../utils/get-schema.js';
+import { transaction } from '../utils/transaction.js';
 import { ItemsService } from './items.js';
 import { PermissionsService } from './permissions/index.js';
 export class RelationsService {
@@ -150,7 +151,7 @@ export class RelationsService {
                 many_field: relation.field,
                 one_collection: relation.related_collection || null,
             };
-            await this.knex.transaction(async (trx) => {
+            await transaction(this.knex, async (trx) => {
                 if (relation.related_collection) {
                     await trx.schema.alterTable(relation.collection, async (table) => {
                         this.alterType(table, relation, fieldSchema.nullable);
@@ -161,6 +162,9 @@ export class RelationsService {
                         if (relation.schema?.on_delete) {
                             builder.onDelete(relation.schema.on_delete);
                         }
+                        if (relation.schema?.on_update) {
+                            builder.onUpdate(relation.schema.on_update);
+                        }
                     });
                 }
                 const relationsItemService = new ItemsService('directus_relations', {
@@ -218,7 +222,7 @@ export class RelationsService {
         this.helpers.schema.preRelationChange(relation);
         const nestedActionEvents = [];
         try {
-            await this.knex.transaction(async (trx) => {
+            await transaction(this.knex, async (trx) => {
                 if (existingRelation.related_collection) {
                     await trx.schema.alterTable(collection, async (table) => {
                         let constraintName = getDefaultIndexName('foreign', collection, field);
@@ -236,6 +240,9 @@ export class RelationsService {
                         if (relation.schema?.on_delete) {
                             builder.onDelete(relation.schema.on_delete);
                         }
+                        if (relation.schema?.on_update) {
+                            builder.onUpdate(relation.schema.on_update);
+                        }
                     });
                 }
                 const relationsItemService = new ItemsService('directus_relations', {
@@ -302,7 +309,7 @@ export class RelationsService {
         const runPostColumnChange = await this.helpers.schema.preColumnChange();
         const nestedActionEvents = [];
         try {
-            await this.knex.transaction(async (trx) => {
+            await transaction(this.knex, async (trx) => {
                 const existingConstraints = await this.schemaInspector.foreignKeys();
                 const constraintNames = existingConstraints.map((key) => key.constraint_name);
                 if (existingRelation.schema?.constraint_name &&

package/dist/services/revisions.d.ts

@@ -1,4 +1,5 @@
-import type { AbstractServiceOptions, Item, MutationOptions, PrimaryKey } from '../types/index.js';
+import type { Item, PrimaryKey } from '@directus/types';
+import type { AbstractServiceOptions, MutationOptions } from '../types/index.js';
 import { ItemsService } from './items.js';
 export declare class RevisionsService extends ItemsService {
     constructor(options: AbstractServiceOptions);

package/dist/services/roles.d.ts

@@ -1,5 +1,5 @@
-import type { Query } from '@directus/types';
-import type { AbstractServiceOptions, Item, MutationOptions, PrimaryKey } from '../types/index.js';
+import type { Item, PrimaryKey, Query } from '@directus/types';
+import type { AbstractServiceOptions, MutationOptions } from '../types/index.js';
 import { ItemsService } from './items.js';
 export declare class RolesService extends ItemsService {
     constructor(options: AbstractServiceOptions);

package/dist/services/roles.js

@@ -1,5 +1,6 @@
 import { ForbiddenError, InvalidPayloadError, UnprocessableContentError } from '@directus/errors';
 import { getMatch } from 'ip-matching';
+import { transaction } from '../utils/transaction.js';
 import { ItemsService } from './items.js';
 import { PermissionsService } from './permissions/index.js';
 import { PresetsService } from './presets.js';
@@ -217,7 +218,7 @@ export class RolesService extends ItemsService {
         catch (err) {
             opts.preMutationError = err;
         }
-        await this.knex.transaction(async (trx) => {
+        await transaction(this.knex, async (trx) => {
             const itemsService = new ItemsService('directus_roles', {
                 knex: trx,
                 accountability: this.accountability,

package/dist/services/shares.d.ts

@@ -1,4 +1,5 @@
-import type { AbstractServiceOptions, Item, LoginResult, MutationOptions, PrimaryKey } from '../types/index.js';
+import type { Item, PrimaryKey } from '@directus/types';
+import type { AbstractServiceOptions, LoginResult, MutationOptions } from '../types/index.js';
 import { AuthorizationService } from './authorization.js';
 import { ItemsService } from './items.js';
 export declare class SharesService extends ItemsService {

package/dist/services/shares.js

@@ -2,6 +2,7 @@ import { useEnv } from '@directus/env';
 import { ForbiddenError, InvalidCredentialsError } from '@directus/errors';
 import argon2 from 'argon2';
 import jwt from 'jsonwebtoken';
+import { useLogger } from '../logger.js';
 import { getMilliseconds } from '../utils/get-milliseconds.js';
 import { md } from '../utils/md.js';
 import { Url } from '../utils/url.js';
@@ -10,7 +11,6 @@ import { AuthorizationService } from './authorization.js';
 import { ItemsService } from './items.js';
 import { MailService } from './mail/index.js';
 import { UsersService } from './users.js';
-import { useLogger } from '../logger.js';
 const env = useEnv();
 const logger = useLogger();
 export class SharesService extends ItemsService {

package/dist/services/tfa.d.ts

@@ -1,5 +1,6 @@
+import type { PrimaryKey } from '@directus/types';
 import type { Knex } from 'knex';
-import type { AbstractServiceOptions, PrimaryKey } from '../types/index.js';
+import type { AbstractServiceOptions } from '../types/index.js';
 import { ItemsService } from './items.js';
 export declare class TFAService {
     knex: Knex;

package/dist/services/tfa.js

@@ -1,6 +1,6 @@
+import { InvalidPayloadError } from '@directus/errors';
 import { authenticator } from 'otplib';
 import getDatabase from '../database/index.js';
-import { InvalidPayloadError } from '@directus/errors';
 import { ItemsService } from './items.js';
 export class TFAService {
     knex;

package/dist/services/users.d.ts

@@ -1,5 +1,5 @@
-import type { Query } from '@directus/types';
-import type { AbstractServiceOptions, Item, MutationOptions, PrimaryKey } from '../types/index.js';
+import type { Item, PrimaryKey, Query } from '@directus/types';
+import type { AbstractServiceOptions, MutationOptions } from '../types/index.js';
 import { ItemsService } from './items.js';
 export declare class UsersService extends ItemsService {
     constructor(options: AbstractServiceOptions);

package/dist/services/users.js

@@ -7,14 +7,15 @@ import jwt from 'jsonwebtoken';
 import { cloneDeep, isEmpty } from 'lodash-es';
 import { performance } from 'perf_hooks';
 import getDatabase from '../database/index.js';
+import { useLogger } from '../logger.js';
 import isUrlAllowed from '../utils/is-url-allowed.js';
 import { verifyJWT } from '../utils/jwt.js';
 import { stall } from '../utils/stall.js';
+import { transaction } from '../utils/transaction.js';
 import { Url } from '../utils/url.js';
 import { ItemsService } from './items.js';
 import { MailService } from './mail/index.js';
 import { SettingsService } from './settings.js';
-import { useLogger } from '../logger.js';
 const env = useEnv();
 const logger = useLogger();
 export class UsersService extends ItemsService {
@@ -195,7 +196,7 @@ export class UsersService extends ItemsService {
             opts.mutationTracker = this.createMutationTracker();
         const primaryKeyField = this.schema.collections[this.collection].primary;
         const keys = [];
-        await this.knex.transaction(async (trx) => {
+        await transaction(this.knex, async (trx) => {
             const service = new UsersService({
                 accountability: this.accountability,
                 knex: trx,

package/dist/services/utils.d.ts

@@ -1,6 +1,6 @@
-import type { Accountability, SchemaOverview } from '@directus/types';
+import type { Accountability, PrimaryKey, SchemaOverview } from '@directus/types';
 import type { Knex } from 'knex';
-import type { AbstractServiceOptions, PrimaryKey } from '../types/index.js';
+import type { AbstractServiceOptions } from '../types/index.js';
 export declare class UtilsService {
     knex: Knex;
     accountability: Accountability | null;

package/dist/services/utils.js

@@ -1,8 +1,8 @@
+import { ForbiddenError, InvalidPayloadError } from '@directus/errors';
+import { systemCollectionRows } from '@directus/system-data';
 import { flushCaches, getCache } from '../cache.js';
 import getDatabase from '../database/index.js';
-import { systemCollectionRows } from '@directus/system-data';
 import emitter from '../emitter.js';
-import { ForbiddenError, InvalidPayloadError } from '@directus/errors';
 import { shouldClearCache } from '../utils/should-clear-cache.js';
 export class UtilsService {
     knex;

package/dist/services/versions.d.ts

@@ -17,5 +17,5 @@ export declare class VersionsService extends ItemsService {
     createMany(data: Partial<Item>[], opts?: MutationOptions): Promise<PrimaryKey[]>;
     updateMany(keys: PrimaryKey[], data: Partial<Item>, opts?: MutationOptions): Promise<PrimaryKey[]>;
     save(key: PrimaryKey, data: Partial<Item>): Promise<Partial<Item>>;
-    promote(version: PrimaryKey, mainHash: string, fields?: string[]): Promise<import("../types/items.js").PrimaryKey>;
+    promote(version: PrimaryKey, mainHash: string, fields?: string[]): Promise<PrimaryKey>;
 }

package/dist/services/webhooks.d.ts

@@ -1,11 +1,15 @@
+import { type DirectusError } from '@directus/errors';
 import type { Bus } from '@directus/memory';
-import type { AbstractServiceOptions, Item, MutationOptions, PrimaryKey, Webhook } from '../types/index.js';
+import type { PrimaryKey } from '@directus/types';
+import type { AbstractServiceOptions, MutationOptions, Webhook } from '../types/index.js';
 import { ItemsService } from './items.js';
 export declare class WebhooksService extends ItemsService<Webhook> {
     messenger: Bus;
+    errorDeprecation: DirectusError;
     constructor(options: AbstractServiceOptions);
-    createOne(data: Partial<Item>, opts?: MutationOptions): Promise<PrimaryKey>;
-    createMany(data: Partial<Item>[], opts?: MutationOptions): Promise<PrimaryKey[]>;
-    updateMany(keys: PrimaryKey[], data: Partial<Item>, opts?: MutationOptions): Promise<PrimaryKey[]>;
+    createOne(): Promise<PrimaryKey>;
+    createMany(): Promise<PrimaryKey[]>;
+    updateBatch(): Promise<PrimaryKey[]>;
+    updateMany(): Promise<PrimaryKey[]>;
     deleteMany(keys: PrimaryKey[], opts?: MutationOptions): Promise<PrimaryKey[]>;
 }

package/dist/services/webhooks.js

@@ -1,25 +1,28 @@
+import { ErrorCode, createError } from '@directus/errors';
 import { useBus } from '../bus/index.js';
+import { useLogger } from '../logger.js';
 import { ItemsService } from './items.js';
+const logger = useLogger();
 export class WebhooksService extends ItemsService {
     messenger;
+    errorDeprecation;
     constructor(options) {
         super('directus_webhooks', options);
         this.messenger = useBus();
+        this.errorDeprecation = new (createError(ErrorCode.MethodNotAllowed, 'Webhooks are deprecated, use Flows instead', 405))();
+        logger.warn('Webhooks are deprecated and the WebhooksService will be removed in an upcoming release. Creating/Updating Webhooks is disabled, use Flows instead');
     }
-    async createOne(data, opts) {
-        const result = await super.createOne(data, opts);
-        this.messenger.publish('webhooks', { type: 'reload' });
-        return result;
+    async createOne() {
+        throw this.errorDeprecation;
     }
-    async createMany(data, opts) {
-        const result = await super.createMany(data, opts);
-        this.messenger.publish('webhooks', { type: 'reload' });
-        return result;
+    async createMany() {
+        throw this.errorDeprecation;
     }
-    async updateMany(keys, data, opts) {
-        const result = await super.updateMany(keys, data, opts);
-        this.messenger.publish('webhooks', { type: 'reload' });
-        return result;
+    async updateBatch() {
+        throw this.errorDeprecation;
+    }
+    async updateMany() {
+        throw this.errorDeprecation;
     }
     async deleteMany(keys, opts) {
         const result = await super.deleteMany(keys, opts);

package/dist/types/items.d.ts

@@ -1,13 +1,6 @@
 import type { DirectusError } from '@directus/errors';
-import type { EventContext } from '@directus/types';
+import type { EventContext, PrimaryKey } from '@directus/types';
 import type { MutationTracker } from '../services/items.js';
-export type Item = Record<string, any>;
-export type PrimaryKey = string | number;
-export type Alterations<T extends Item = Item, K extends keyof T | undefined = undefined> = {
-    create: Partial<T>[];
-    update: (K extends keyof T ? Partial<T> & Pick<T, K> : Partial<T>)[];
-    delete: (K extends keyof T ? T[K] : PrimaryKey)[];
-};
 export type MutationOptions = {
     /**
      * Callback function that's fired whenever a revision is made in the mutation

package/dist/types/services.d.ts

@@ -1,6 +1,5 @@
-import type { Accountability, Query, SchemaOverview } from '@directus/types';
+import type { Accountability, Item, PrimaryKey, Query, SchemaOverview } from '@directus/types';
 import type { Knex } from 'knex';
-import type { Item, PrimaryKey } from './items.js';
 export type AbstractServiceOptions = {
     knex?: Knex | undefined;
     accountability?: Accountability | null | undefined;

package/dist/utils/apply-diff.js

@@ -9,6 +9,7 @@ import { CollectionsService } from '../services/collections.js';
 import { FieldsService } from '../services/fields.js';
 import { RelationsService } from '../services/relations.js';
 import { DiffKind } from '../types/index.js';
+import { transaction } from '../utils/transaction.js';
 import { getSchema } from './get-schema.js';
 const logger = useLogger();
 export async function applyDiff(currentSnapshot, snapshotDiff, options) {
@@ -22,7 +23,7 @@ export async function applyDiff(currentSnapshot, snapshotDiff, options) {
         bypassLimits: true,
     };
     const runPostColumnChange = await helpers.schema.preColumnChange();
-    await database.transaction(async (trx) => {
+    await transaction(database, async (trx) => {
         const collectionsService = new CollectionsService({ knex: trx, schema });
         const getNestedCollectionsToCreate = (currentLevelCollection) => snapshotDiff.collections.filter(({ diff }) => diff[0].rhs?.meta?.group === currentLevelCollection);
         const getNestedCollectionsToDelete = (currentLevelCollection) => snapshotDiff.collections.filter(({ diff }) => diff[0].lhs?.meta?.group === currentLevelCollection);

package/dist/utils/get-ast-from-query.js

@@ -73,7 +73,7 @@ export default async function getASTFromQuery(collection, query, schema, options
         for (const fieldKey of fields) {
             let name = fieldKey;
             if (query.alias) {
-                // check for field alias (is is one of the key)
+                // check for field alias (is one of the key)
                 if (name in query.alias) {
                     name = query.alias[fieldKey];
                 }

package/dist/utils/get-auth-providers.d.ts

@@ -4,5 +4,7 @@ interface AuthProvider {
     icon?: string;
     label?: string;
 }
-export declare function getAuthProviders(): AuthProvider[];
+export declare function getAuthProviders({ sessionOnly }?: {
+    sessionOnly: boolean;
+}): AuthProvider[];
 export {};

package/dist/utils/get-auth-providers.js

@@ -1,10 +1,21 @@
 import { useEnv } from '@directus/env';
 import { toArray } from '@directus/utils';
-export function getAuthProviders() {
+export function getAuthProviders({ sessionOnly } = { sessionOnly: false }) {
     const env = useEnv();
-    return toArray(env['AUTH_PROVIDERS'])
-        .filter((provider) => provider && env[`AUTH_${provider.toUpperCase()}_DRIVER`])
-        .map((provider) => ({
+    let providers = toArray(env['AUTH_PROVIDERS']).filter((provider) => provider && env[`AUTH_${provider.toUpperCase()}_DRIVER`]);
+    if (sessionOnly) {
+        providers = providers.filter((provider) => {
+            const driver = env[`AUTH_${provider.toUpperCase()}_DRIVER`];
+            // only the following 3 drivers require a mode selection
+            if (['oauth2', 'openid', 'saml'].includes(driver)) {
+                const mode = env[`AUTH_${provider.toUpperCase()}_MODE`];
+                // if mode is not defined it defaults to session
+                return !mode || mode === 'session';
+            }
+            return true;
+        });
+    }
+    return providers.map((provider) => ({
         name: provider,
         label: env[`AUTH_${provider.toUpperCase()}_LABEL`],
         driver: env[`AUTH_${provider.toUpperCase()}_DRIVER`],

package/dist/utils/get-cache-headers.js

@@ -16,9 +16,6 @@ export function getCacheControlHeader(req, ttl, globalCacheSettings, personalize
     // When the resource / current request shouldn't be cached
     if (ttl === undefined || ttl < 0)
         return 'no-cache';
-    // When the API cache can invalidate at any moment
-    if (globalCacheSettings && env['CACHE_AUTO_PURGE'] === true)
-        return 'no-cache';
     const headerValues = [];
     // When caching depends on the authentication status of the users
     if (personalized) {

package/dist/utils/get-schema.d.ts

@@ -7,4 +7,4 @@ export declare function getSchema(options?: {
      * Used to ensure schema snapshot/apply is not using outdated schema
      */
     bypassCache?: boolean;
-}): Promise<SchemaOverview>;
+}, attempt?: number): Promise<SchemaOverview>;

package/dist/utils/get-schema.js

@@ -1,47 +1,70 @@
 import { useEnv } from '@directus/env';
 import { createInspector } from '@directus/schema';
+import { systemCollectionRows } from '@directus/system-data';
 import { parseJSON, toArray } from '@directus/utils';
 import { mapValues } from 'lodash-es';
+import { useBus } from '../bus/index.js';
 import { getSchemaCache, setSchemaCache } from '../cache.js';
 import { ALIAS_TYPES } from '../constants.js';
 import getDatabase from '../database/index.js';
+import { useLock } from '../lock/index.js';
 import { useLogger } from '../logger.js';
 import { RelationsService } from '../services/relations.js';
 import getDefaultValue from './get-default-value.js';
-import getLocalType from './get-local-type.js';
-import { systemCollectionRows } from '@directus/system-data';
 import { getSystemFieldRowsWithAuthProviders } from './get-field-system-rows.js';
+import getLocalType from './get-local-type.js';
 const logger = useLogger();
-export async function getSchema(options) {
+export async function getSchema(options, attempt = 0) {
+    const MAX_ATTEMPTS = 3;
     const env = useEnv();
-    const database = options?.database || getDatabase();
-    const schemaInspector = createInspector(database);
-    let result;
-    if (!options?.bypassCache && env['CACHE_SCHEMA'] !== false) {
-        let cachedSchema;
-        try {
-            cachedSchema = await getSchemaCache();
-        }
-        catch (err) {
-            logger.warn(err, `[schema-cache] Couldn't retrieve cache. ${err}`);
-        }
-        if (cachedSchema) {
-            result = cachedSchema;
-        }
-        else {
-            result = await getDatabaseSchema(database, schemaInspector);
-            try {
-                await setSchemaCache(result);
-            }
-            catch (err) {
-                logger.warn(err, `[schema-cache] Couldn't save cache. ${err}`);
-            }
-        }
+    if (attempt >= MAX_ATTEMPTS) {
+        throw new Error(`Failed to get Schema information: hit infinite loop`);
     }
-    else {
-        result = await getDatabaseSchema(database, schemaInspector);
+    if (options?.bypassCache || env['CACHE_SCHEMA'] === false) {
+        const database = options?.database || getDatabase();
+        const schemaInspector = createInspector(database);
+        return await getDatabaseSchema(database, schemaInspector);
+    }
+    const cached = await getSchemaCache();
+    if (cached) {
+        return cached;
+    }
+    const lock = useLock();
+    const bus = useBus();
+    const lockKey = 'schemaCache--preparing';
+    const messageKey = 'schemaCache--done';
+    const processId = await lock.increment(lockKey);
+    const currentProcessShouldHandleOperation = processId === 1;
+    if (currentProcessShouldHandleOperation === false) {
+        logger.trace('Schema cache is prepared in another process, waiting for result.');
+        return new Promise((resolve) => {
+            const TIMEOUT = 10000;
+            let timeout;
+            const callback = async () => {
+                if (timeout)
+                    clearTimeout(timeout);
+                const schema = await getSchema(options, attempt + 1);
+                resolve(schema);
+                bus.unsubscribe(messageKey, callback);
+            };
+            bus.subscribe(messageKey, callback);
+            timeout = setTimeout(async () => {
+                logger.trace('Did not receive schema callback message in time. Pulling schema...');
+                callback();
+            }, TIMEOUT);
+        });
+    }
+    try {
+        const database = options?.database || getDatabase();
+        const schemaInspector = createInspector(database);
+        const schema = await getDatabaseSchema(database, schemaInspector);
+        await setSchemaCache(schema);
+        return schema;
+    }
+    finally {
+        await lock.delete(lockKey);
+        bus.publish(messageKey, { ready: true });
     }
-    return result;
 }
 async function getDatabaseSchema(database, schemaInspector) {
     const env = useEnv();

package/dist/utils/merge-version-data.js

@@ -1,5 +1,5 @@
-import Joi from 'joi';
 import { isObject } from '@directus/utils';
+import Joi from 'joi';
 import { cloneDeep } from 'lodash-es';
 const alterationSchema = Joi.object({
     create: Joi.array().items(Joi.object().unknown()),

package/dist/utils/transaction.d.ts

@@ -0,0 +1,9 @@
+import type { Knex } from 'knex';
+/**
+ * Execute the given handler within the current transaction or a newly created one
+ * if the current knex state isn't a transaction yet.
+ *
+ * Can be used to ensure the handler is run within a transaction,
+ * while preventing nested transactions.
+ */
+export declare const transaction: <T = unknown>(knex: Knex, handler: (knex: Knex) => Promise<T>) => Promise<T>;

package/dist/utils/transaction.js

@@ -0,0 +1,15 @@
+/**
+ * Execute the given handler within the current transaction or a newly created one
+ * if the current knex state isn't a transaction yet.
+ *
+ * Can be used to ensure the handler is run within a transaction,
+ * while preventing nested transactions.
+ */
+export const transaction = (knex, handler) => {
+    if (knex.isTransaction) {
+        return handler(knex);
+    }
+    else {
+        return knex.transaction((trx) => handler(trx));
+    }
+};

package/dist/utils/validate-keys.d.ts

@@ -1,5 +1,4 @@
-import type { SchemaOverview } from '@directus/types';
-import type { PrimaryKey } from '../types/index.js';
+import type { PrimaryKey, SchemaOverview } from '@directus/types';
 /**
  * Validate keys based on its type
  */