@directus/api 18.2.0 → 19.0.0

package/dist/app.js

@@ -60,7 +60,6 @@ import { getConfigFromEnv } from './utils/get-config-from-env.js';
 import { Url } from './utils/url.js';
 import { validateEnv } from './utils/validate-env.js';
 import { validateStorage } from './utils/validate-storage.js';
-import { init as initWebhooks } from './webhooks.js';
 const require = createRequire(import.meta.url);
 export default async function createApp() {
     const env = useEnv();
@@ -240,8 +239,6 @@ export default async function createApp() {
     app.use(notFoundHandler);
     app.use(errorHandler);
     await emitter.emitInit('routes.after', { app });
-    // Register all webhooks
-    await initWebhooks();
     initTelemetry();
     await emitter.emitInit('app.after', { app });
     return app;

package/dist/auth/drivers/ldap.js

@@ -299,7 +299,7 @@ export function createLDAPAuthRouter(provider) {
             ip: getIPFromReq(req),
             role: null,
         };
-        const userAgent = req.get('user-agent');
+        const userAgent = req.get('user-agent')?.substring(0, 1024);
         if (userAgent)
             accountability.userAgent = userAgent;
         const origin = req.get('origin');

package/dist/auth/drivers/local.js

@@ -51,7 +51,7 @@ export function createLocalAuthRouter(provider) {
             ip: getIPFromReq(req),
             role: null,
         };
-        const userAgent = req.get('user-agent');
+        const userAgent = req.get('user-agent')?.substring(0, 1024);
         if (userAgent)
             accountability.userAgent = userAgent;
         const origin = req.get('origin');

package/dist/auth/drivers/oauth2.js

@@ -254,7 +254,7 @@ export function createOAuth2AuthRouter(providerName) {
             ip: getIPFromReq(req),
             role: null,
         };
-        const userAgent = req.get('user-agent');
+        const userAgent = req.get('user-agent')?.substring(0, 1024);
         if (userAgent)
             accountability.userAgent = userAgent;
         const origin = req.get('origin');

package/dist/auth/drivers/openid.js

@@ -275,7 +275,7 @@ export function createOpenIDAuthRouter(providerName) {
             ip: getIPFromReq(req),
             role: null,
         };
-        const userAgent = req.get('user-agent');
+        const userAgent = req.get('user-agent')?.substring(0, 1024);
         if (userAgent)
             accountability.userAgent = userAgent;
         const origin = req.get('origin');

package/dist/cache.js

@@ -80,7 +80,7 @@ export async function getSystemCache(key) {
 }
 export async function setSchemaCache(schema) {
     const { localSchemaCache, sharedSchemaCache } = getCache();
-    const schemaHash = await getSimpleHash(JSON.stringify(schema));
+    const schemaHash = getSimpleHash(JSON.stringify(schema));
     await sharedSchemaCache.set('hash', schemaHash);
     await localSchemaCache.set('schema', schema);
     await localSchemaCache.set('hash', schemaHash);

package/dist/controllers/activity.js

@@ -70,7 +70,7 @@ router.post('/comment', asyncHandler(async (req, res, next) => {
         action: Action.COMMENT,
         user: req.accountability?.user,
         ip: getIPFromReq(req),
-        user_agent: req.get('user-agent'),
+        user_agent: req.accountability?.userAgent,
         origin: req.get('origin'),
     });
     try {

package/dist/controllers/auth.js

@@ -74,7 +74,7 @@ router.post('/refresh', asyncHandler(async (req, res, next) => {
         ip: getIPFromReq(req),
         role: null,
     };
-    const userAgent = req.get('user-agent');
+    const userAgent = req.get('user-agent')?.substring(0, 1024);
     if (userAgent)
         accountability.userAgent = userAgent;
     const origin = req.get('origin');
@@ -114,7 +114,7 @@ router.post('/logout', asyncHandler(async (req, res, next) => {
         ip: getIPFromReq(req),
         role: null,
     };
-    const userAgent = req.get('user-agent');
+    const userAgent = req.get('user-agent')?.substring(0, 1024);
     if (userAgent)
         accountability.userAgent = userAgent;
     const origin = req.get('origin');
@@ -148,7 +148,7 @@ router.post('/password/request', asyncHandler(async (req, _res, next) => {
         ip: getIPFromReq(req),
         role: null,
     };
-    const userAgent = req.get('user-agent');
+    const userAgent = req.get('user-agent')?.substring(0, 1024);
     if (userAgent)
         accountability.userAgent = userAgent;
     const origin = req.get('origin');
@@ -180,7 +180,7 @@ router.post('/password/reset', asyncHandler(async (req, _res, next) => {
         ip: getIPFromReq(req),
         role: null,
     };
-    const userAgent = req.get('user-agent');
+    const userAgent = req.get('user-agent')?.substring(0, 1024);
     if (userAgent)
         accountability.userAgent = userAgent;
     const origin = req.get('origin');
@@ -190,9 +190,10 @@ router.post('/password/reset', asyncHandler(async (req, _res, next) => {
     await service.resetPassword(req.body.token, req.body.password);
     return next();
 }), respond);
-router.get('/', asyncHandler(async (_req, res, next) => {
+router.get('/', asyncHandler(async (req, res, next) => {
+    const sessionOnly = 'sessionOnly' in req.query && (req.query['sessionOnly'] === '' || Boolean(req.query['sessionOnly']));
     res.locals['payload'] = {
-        data: getAuthProviders(),
+        data: getAuthProviders({ sessionOnly }),
         disableDefault: env['AUTH_DISABLE_DEFAULT'],
     };
     return next();

package/dist/controllers/extensions.js

@@ -101,6 +101,36 @@ router.post('/registry/install', asyncHandler(async (req, _res, next) => {
     await service.install(extension, version);
     return next();
 }), respond);
+router.post('/registry/reinstall', asyncHandler(async (req, _res, next) => {
+    if (req.accountability && req.accountability.admin !== true) {
+        throw new ForbiddenError();
+    }
+    const { extension } = req.body;
+    if (!extension) {
+        throw new ForbiddenError();
+    }
+    const service = new ExtensionsService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    await service.reinstall(extension);
+    return next();
+}), respond);
+router.delete(`/registry/uninstall/:pk(${UUID_REGEX})`, asyncHandler(async (req, _res, next) => {
+    if (req.accountability && req.accountability.admin !== true) {
+        throw new ForbiddenError();
+    }
+    const pk = req.params['pk'];
+    if (typeof pk !== 'string') {
+        throw new ForbiddenError();
+    }
+    const service = new ExtensionsService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    await service.uninstall(pk);
+    return next();
+}), respond);
 router.patch(`/:pk(${UUID_REGEX})`, asyncHandler(async (req, res, next) => {
     if (req.accountability && req.accountability.admin !== true) {
         throw new ForbiddenError();

package/dist/controllers/fields.js

@@ -85,9 +85,7 @@ router.patch('/:collection', validateCollection, asyncHandler(async (req, res, n
     if (Array.isArray(req.body) === false) {
         throw new InvalidPayloadError({ reason: 'Submitted body has to be an array' });
     }
-    for (const field of req.body) {
-        await service.updateField(req.params['collection'], field);
-    }
+    await service.updateFields(req.params['collection'], req.body);
     try {
         const results = [];
         for (const field of req.body) {

package/dist/controllers/webhooks.js

@@ -1,6 +1,5 @@
-import { isDirectusError } from '@directus/errors';
+import { ErrorCode, createError } from '@directus/errors';
 import express from 'express';
-import { ErrorCode } from '@directus/errors';
 import { respond } from '../middleware/respond.js';
 import useCollection from '../middleware/use-collection.js';
 import { validateBatch } from '../middleware/validate-batch.js';
@@ -10,37 +9,9 @@ import asyncHandler from '../utils/async-handler.js';
 import { sanitizeQuery } from '../utils/sanitize-query.js';
 const router = express.Router();
 router.use(useCollection('directus_webhooks'));
-router.post('/', asyncHandler(async (req, res, next) => {
-    const service = new WebhooksService({
-        accountability: req.accountability,
-        schema: req.schema,
-    });
-    const savedKeys = [];
-    if (Array.isArray(req.body)) {
-        const keys = await service.createMany(req.body);
-        savedKeys.push(...keys);
-    }
-    else {
-        const key = await service.createOne(req.body);
-        savedKeys.push(key);
-    }
-    try {
-        if (Array.isArray(req.body)) {
-            const items = await service.readMany(savedKeys, req.sanitizedQuery);
-            res.locals['payload'] = { data: items };
-        }
-        else {
-            const item = await service.readOne(savedKeys[0], req.sanitizedQuery);
-            res.locals['payload'] = { data: item };
-        }
-    }
-    catch (error) {
-        if (isDirectusError(error, ErrorCode.Forbidden)) {
-            return next();
-        }
-        throw error;
-    }
-    return next();
+router.post('/', asyncHandler(async (_req, _res, _next) => {
+    // Disallow creation of new Webhooks as part of the deprecation, see https://github.com/directus/directus/issues/15553
+    throw new (createError(ErrorCode.MethodNotAllowed, 'Webhooks are deprecated, use Flows instead', 405))();
 }), respond);
 const readHandler = asyncHandler(async (req, res, next) => {
     const service = new WebhooksService({
@@ -67,48 +38,13 @@ router.get('/:pk', asyncHandler(async (req, res, next) => {
     res.locals['payload'] = { data: record || null };
     return next();
 }), respond);
-router.patch('/', validateBatch('update'), asyncHandler(async (req, res, next) => {
-    const service = new WebhooksService({
-        accountability: req.accountability,
-        schema: req.schema,
-    });
-    let keys = [];
-    if (req.body.keys) {
-        keys = await service.updateMany(req.body.keys, req.body.data);
-    }
-    else {
-        const sanitizedQuery = sanitizeQuery(req.body.query, req.accountability);
-        keys = await service.updateByQuery(sanitizedQuery, req.body.data);
-    }
-    try {
-        const result = await service.readMany(keys, req.sanitizedQuery);
-        res.locals['payload'] = { data: result };
-    }
-    catch (error) {
-        if (isDirectusError(error, ErrorCode.Forbidden)) {
-            return next();
-        }
-        throw error;
-    }
-    return next();
+router.patch('/', validateBatch('update'), asyncHandler(async (_req, _res, _next) => {
+    // Disallow patching of Webhooks as part of the deprecation, see https://github.com/directus/directus/issues/15553
+    throw new (createError(ErrorCode.MethodNotAllowed, 'Webhooks are deprecated, use Flows instead', 405))();
 }), respond);
-router.patch('/:pk', asyncHandler(async (req, res, next) => {
-    const service = new WebhooksService({
-        accountability: req.accountability,
-        schema: req.schema,
-    });
-    const primaryKey = await service.updateOne(req.params['pk'], req.body);
-    try {
-        const item = await service.readOne(primaryKey, req.sanitizedQuery);
-        res.locals['payload'] = { data: item || null };
-    }
-    catch (error) {
-        if (isDirectusError(error, ErrorCode.Forbidden)) {
-            return next();
-        }
-        throw error;
-    }
-    return next();
+router.patch('/:pk', asyncHandler(async (_req, _res, _next) => {
+    // Disallow patching of Webhooks as part of the deprecation, see https://github.com/directus/directus/issues/15553
+    throw new (createError(ErrorCode.MethodNotAllowed, 'Webhooks are deprecated, use Flows instead', 405))();
 }), respond);
 router.delete('/', asyncHandler(async (req, _res, next) => {
     const service = new WebhooksService({

package/dist/database/migrations/20240122A-add-report-url-fields.d.ts

@@ -0,0 +1,3 @@
+import type { Knex } from 'knex';
+export declare function up(knex: Knex): Promise<void>;
+export declare function down(knex: Knex): Promise<void>;

package/dist/database/migrations/20240122A-add-report-url-fields.js

@@ -0,0 +1,14 @@
+export async function up(knex) {
+    await knex.schema.alterTable('directus_settings', (table) => {
+        table.string('report_error_url').nullable();
+        table.string('report_bug_url').nullable();
+        table.string('report_feature_url').nullable();
+    });
+}
+export async function down(knex) {
+    await knex.schema.alterTable('directus_settings', (table) => {
+        table.dropColumn('report_error_url');
+        table.dropColumn('report_bug_url');
+        table.dropColumn('report_feature_url');
+    });
+}

package/dist/database/migrations/20240204A-marketplace.js

@@ -32,7 +32,7 @@ export async function up(knex) {
                 source = 'local';
             }
             await knex('directus_extensions').update({ id, source, folder: name }).where({ name });
-            idMap.set(name, id);
+            idMap.set(name, { id, source });
         }
     }
     for (const { name } of installedExtensions) {
@@ -44,16 +44,28 @@ export async function up(knex) {
             continue;
         const isScopedModuleBundleChild = name.startsWith('@') && splittedName.length > 2;
         const bundleParentName = isScopedModuleBundleParent || isScopedModuleBundleChild ? splittedName.slice(0, 2).join('/') : splittedName[0];
-        const bundleParentId = idMap.get(bundleParentName);
-        if (!bundleParentId)
+        const bundleParent = idMap.get(bundleParentName);
+        if (!bundleParent)
             continue;
         await knex('directus_extensions')
-            .update({ bundle: bundleParentId, folder: name.substring(bundleParentName.length + 1) })
+            .update({
+            bundle: bundleParent.id,
+            folder: name.substring(bundleParentName.length + 1),
+            source: bundleParent.source,
+        })
             .where({ folder: name });
     }
+    await knex.schema.alterTable('directus_extensions', (table) => {
+        table.uuid('id').alter().notNullable();
+    });
+    await knex.transaction(async (trx) => {
+        await trx.schema.alterTable('directus_extensions', (table) => {
+            table.dropPrimary();
+            table.primary(['id']);
+        });
+    });
     await knex.schema.alterTable('directus_extensions', (table) => {
         table.dropColumn('name');
-        table.uuid('id').alter().primary().notNullable();
         table.string('source').alter().notNullable();
         table.string('folder').alter().notNullable();
     });

package/dist/database/migrations/20240305A-change-useragent-type.d.ts

@@ -0,0 +1,3 @@
+import type { Knex } from 'knex';
+export declare function up(knex: Knex): Promise<void>;
+export declare function down(knex: Knex): Promise<void>;

package/dist/database/migrations/20240305A-change-useragent-type.js

@@ -0,0 +1,19 @@
+import { getHelpers } from '../helpers/index.js';
+export async function up(knex) {
+    const helper = getHelpers(knex).schema;
+    await Promise.all([
+        helper.changeToType('directus_activity', 'user_agent', 'text'),
+        helper.changeToType('directus_sessions', 'user_agent', 'text'),
+    ]);
+}
+export async function down(knex) {
+    const helper = await getHelpers(knex).schema;
+    const opts = {
+        nullable: false,
+        length: 255,
+    };
+    await Promise.all([
+        helper.changeToType('directus_activity', 'user_agent', 'string', opts),
+        helper.changeToType('directus_sessions', 'user_agent', 'string', opts),
+    ]);
+}

package/dist/database/migrations/20240311A-deprecate-webhooks.d.ts

@@ -0,0 +1,13 @@
+import type { Knex } from 'knex';
+/**
+ * 0. Identify and persist which webhooks were active before deprecation
+ * 1. Migrate existing webhooks over to identically behaving Flows
+ * 2. Disable existing webhooks
+ * 3. Dont drop webhooks yet
+ */
+export declare function up(knex: Knex): Promise<void>;
+/**
+ * Dont completely drop Webhooks yet.
+ * Lets preserve the data and drop them in the next release to be extra safe with users data.
+ */
+export declare function down(knex: Knex): Promise<void>;

package/dist/database/migrations/20240311A-deprecate-webhooks.js

@@ -0,0 +1,125 @@
+import { parseJSON, toArray } from '@directus/utils';
+import { randomUUID } from 'node:crypto';
+// To avoid typos
+const TABLE_WEBHOOKS = 'directus_webhooks';
+const TABLE_FLOWS = 'directus_flows';
+const TABLE_OPERATIONS = 'directus_operations';
+const NEW_COLUMN_WAS_ACTIVE = 'was_active_before_deprecation';
+const NEW_COLUMN_FLOW = 'migrated_flow';
+/**
+ * 0. Identify and persist which webhooks were active before deprecation
+ * 1. Migrate existing webhooks over to identically behaving Flows
+ * 2. Disable existing webhooks
+ * 3. Dont drop webhooks yet
+ */
+export async function up(knex) {
+    // 0. Identify and persist which webhooks were active before deprecation
+    await knex.schema.alterTable(TABLE_WEBHOOKS, (table) => {
+        table.boolean(NEW_COLUMN_WAS_ACTIVE).notNullable().defaultTo(false);
+        table.uuid(NEW_COLUMN_FLOW).nullable();
+        table.foreign(NEW_COLUMN_FLOW).references(`${TABLE_FLOWS}.id`).onDelete('SET NULL');
+    });
+    await knex(TABLE_WEBHOOKS)
+        .update({ [NEW_COLUMN_WAS_ACTIVE]: true })
+        .where({ status: 'active' });
+    const webhooks = await knex.select('*').from(TABLE_WEBHOOKS);
+    // 1. Migrate existing webhooks over to identically behaving Flows
+    await knex.transaction(async (trx) => {
+        for (const webhook of webhooks) {
+            const flowId = randomUUID();
+            const operationIdRunScript = randomUUID();
+            const operationIdWebhook = randomUUID();
+            const newFlow = {
+                id: flowId,
+                name: webhook.name,
+                icon: 'webhook',
+                // color: null,
+                description: 'Auto-generated by Directus Migration\n\nWebhooks were deprecated and have been moved into Flows for you automatically.',
+                status: webhook.status, // Only activate already active webhooks!
+                trigger: 'event',
+                // accountability: "all",
+                options: {
+                    type: 'action',
+                    scope: toArray(webhook.actions)
+                        .filter((action) => action.trim() !== '')
+                        .map((scope) => `items.${scope}`),
+                    collections: toArray(webhook.collections).filter((collection) => collection.trim() !== ''),
+                },
+                operation: null, // Fill this in later --> `operationIdRunScript`
+                // date_created: Default Date,
+                // user_created: null,
+            };
+            const operationRunScript = {
+                id: operationIdRunScript,
+                name: 'Transforming Payload for Webhook',
+                key: 'payload-transform',
+                type: 'exec',
+                position_x: 19,
+                position_y: 1,
+                options: {
+                    code: '/**\n * Webhook data slightly differs from Flow trigger data.\n * This flow converts the new Flow format into the older Webhook shape\n * in order to not break existing logic of consumers.\n */ \nmodule.exports = async function(data) {\n    const crudOperation = data.$trigger.event.split(".").at(-1);\n    const keyOrKeys = crudOperation === "create" ? "key" : "keys";\n    return {\n        event: `items.${crudOperation}`,\n        accountability: { user: data.$accountability.user, role: data.$accountability.role },\n        payload: data.$trigger.payload,\n        [keyOrKeys]: data.$trigger?.[keyOrKeys],\n        collection: data.$trigger.collection,\n    };\n}',
+                },
+                resolve: operationIdWebhook,
+                reject: null,
+                flow: flowId,
+                // date_created: "",
+                // user_created: "",
+            };
+            const operationWebhook = {
+                id: operationIdWebhook,
+                name: 'Webhook',
+                key: 'webhook',
+                type: 'request',
+                position_x: 37,
+                position_y: 1,
+                options: {
+                    url: webhook.url,
+                    body: webhook.data ? '{{$last}}' : undefined,
+                    method: webhook.method,
+                    headers: typeof webhook.headers === 'string' ? parseJSON(webhook.headers) : webhook.headers,
+                },
+                resolve: null,
+                reject: null,
+                flow: flowId,
+                // date_created: "",
+                // user_created: "",
+            };
+            await trx(TABLE_FLOWS).insert(newFlow);
+            // Only need to transform the payload if the webhook enabled transmitting it
+            if (webhook.data && webhook.method !== 'GET') {
+                // Order is important due to IDs
+                await trx(TABLE_OPERATIONS).insert(operationWebhook);
+                await trx(TABLE_OPERATIONS).insert(operationRunScript);
+                await trx(TABLE_FLOWS).update({ operation: operationIdRunScript }).where({ id: flowId });
+            }
+            else {
+                operationWebhook.position_x = 19; // Reset it because the Run-Script will be missing
+                await trx(TABLE_OPERATIONS).insert(operationWebhook);
+                await trx(TABLE_FLOWS).update({ operation: operationIdWebhook }).where({ id: flowId });
+            }
+            // Persist new Flow/s so that we can retroactively remove them on potential down-migrations
+            await trx(TABLE_WEBHOOKS)
+                .update({ [NEW_COLUMN_FLOW]: flowId })
+                .where({ id: webhook.id });
+            // 2. Disable existing webhooks
+            await trx(TABLE_WEBHOOKS).update({ status: 'inactive' });
+        }
+    });
+}
+/**
+ * Dont completely drop Webhooks yet.
+ * Lets preserve the data and drop them in the next release to be extra safe with users data.
+ */
+export async function down(knex) {
+    // Remove Flows created by the up-migration
+    const migratedFlowIds = (await knex(TABLE_WEBHOOKS).select(NEW_COLUMN_FLOW).whereNotNull(NEW_COLUMN_FLOW)).map((col) => col[NEW_COLUMN_FLOW]);
+    await knex(TABLE_FLOWS).delete().whereIn('id', migratedFlowIds);
+    // Restore previously activated webhooks
+    await knex(TABLE_WEBHOOKS)
+        .update({ status: 'active' })
+        .where({ [NEW_COLUMN_WAS_ACTIVE]: true });
+    // Cleanup of up-migration
+    await knex.schema.alterTable(TABLE_WEBHOOKS, (table) => {
+        table.dropColumns(NEW_COLUMN_WAS_ACTIVE, NEW_COLUMN_FLOW);
+    });
+}

package/dist/extensions/manager.d.ts

@@ -81,6 +81,7 @@ export declare class ExtensionManager {
      */
     install(versionId: string): Promise<void>;
     uninstall(folder: string): Promise<void>;
+    broadcastReloadNotification(): Promise<void>;
     /**
      * Load all extensions from disk and register them in their respective places
      */

package/dist/extensions/manager.js

@@ -171,11 +171,14 @@ export class ExtensionManager {
     async install(versionId) {
         await this.installationManager.install(versionId);
         await this.reload({ forceSync: true });
-        await this.messenger.publish(this.reloadChannel, { origin: this.processId });
+        await this.broadcastReloadNotification();
     }
     async uninstall(folder) {
         await this.installationManager.uninstall(folder);
         await this.reload({ forceSync: true });
+        await this.broadcastReloadNotification();
+    }
+    async broadcastReloadNotification() {
         await this.messenger.publish(this.reloadChannel, { origin: this.processId });
     }
     /**

package/dist/middleware/authenticate.js

@@ -15,7 +15,7 @@ export const handler = async (req, _res, next) => {
         app: false,
         ip: getIPFromReq(req),
     };
-    const userAgent = req.get('user-agent');
+    const userAgent = req.get('user-agent')?.substring(0, 1024);
     if (userAgent)
         defaultAccountability.userAgent = userAgent;
     const origin = req.get('origin');

package/dist/services/extensions.d.ts

@@ -15,7 +15,10 @@ export declare class ExtensionsService {
     extensionsItemService: ItemsService<ExtensionSettings>;
     extensionsManager: ExtensionManager;
     constructor(options: AbstractServiceOptions);
+    private preInstall;
     install(extensionId: string, versionId: string): Promise<void>;
+    uninstall(id: string): Promise<void>;
+    reinstall(id: string): Promise<void>;
     readAll(): Promise<ApiOutput[]>;
     readOne(id: string): Promise<ApiOutput>;
     updateOne(id: string, data: DeepPartial<ApiOutput>): Promise<ApiOutput>;

package/dist/services/extensions.js

@@ -29,7 +29,7 @@ export class ExtensionsService {
             accountability: this.accountability,
         });
     }
-    async install(extensionId, versionId) {
+    async preInstall(extensionId, versionId) {
         const env = useEnv();
         const describeOptions = {};
         if (typeof env['MARKETPLACE_REGISTRY'] === 'string') {
@@ -54,6 +54,10 @@ export class ExtensionsService {
                 throw new LimitExceededError();
             }
         }
+        return { extension, version };
+    }
+    async install(extensionId, versionId) {
+        const { extension, version } = await this.preInstall(extensionId, versionId);
         await this.extensionsItemService.createOne({
             id: extensionId,
             enabled: true,
@@ -71,6 +75,38 @@ export class ExtensionsService {
         }
         await this.extensionsManager.install(versionId);
     }
+    async uninstall(id) {
+        const settings = await this.extensionsItemService.readOne(id);
+        if (settings.source !== 'registry') {
+            throw new InvalidPayloadError({
+                reason: 'Cannot uninstall extensions that were not installed via marketplace',
+            });
+        }
+        if (settings.bundle !== null) {
+            throw new InvalidPayloadError({
+                reason: 'Cannot uninstall sub extensions of bundles separately',
+            });
+        }
+        await this.deleteOne(id);
+        await this.extensionsManager.uninstall(settings.folder);
+    }
+    async reinstall(id) {
+        const settings = await this.extensionsItemService.readOne(id);
+        if (settings.source !== 'registry') {
+            throw new InvalidPayloadError({
+                reason: 'Cannot reinstall extensions that were not installed via marketplace',
+            });
+        }
+        if (settings.bundle !== null) {
+            throw new InvalidPayloadError({
+                reason: 'Cannot reinstall sub extensions of bundles separately',
+            });
+        }
+        const extensionId = settings.id;
+        const versionId = settings.folder;
+        await this.preInstall(extensionId, versionId);
+        await this.extensionsManager.install(versionId);
+    }
     async readAll() {
         const settings = await this.extensionsItemService.readByQuery({ limit: -1 });
         const regular = settings.filter(({ bundle }) => bundle === null);
@@ -133,19 +169,14 @@ export class ExtensionsService {
             }
             return extension;
         });
-        this.extensionsManager.reload();
+        this.extensionsManager.reload().then(() => {
+            this.extensionsManager.broadcastReloadNotification();
+        });
         return result;
     }
     async deleteOne(id) {
-        const settings = await this.extensionsItemService.readOne(id);
-        if (settings.source !== 'registry') {
-            throw new InvalidPayloadError({
-                reason: 'Cannot uninstall extensions that were not installed from the marketplace registry',
-            });
-        }
         await this.extensionsItemService.deleteOne(id);
         await this.extensionsItemService.deleteByQuery({ filter: { bundle: { _eq: id } } });
-        await this.extensionsManager.uninstall(settings.folder);
     }
     /**
      * Sync a bundles enabled status

package/dist/services/fields.d.ts

@@ -3,9 +3,9 @@ import type { Accountability, Field, RawField, SchemaOverview, Type } from '@dir
 import type Keyv from 'keyv';
 import type { Knex } from 'knex';
 import type { Helpers } from '../database/helpers/index.js';
+import type { AbstractServiceOptions, MutationOptions } from '../types/index.js';
 import { ItemsService } from './items.js';
 import { PayloadService } from './payload.js';
-import type { AbstractServiceOptions, MutationOptions } from '../types/index.js';
 export declare class FieldsService {
     knex: Knex;
     helpers: Helpers;
@@ -26,6 +26,7 @@ export declare class FieldsService {
     }, table?: Knex.CreateTableBuilder, // allows collection creation to
     opts?: MutationOptions): Promise<void>;
     updateField(collection: string, field: RawField, opts?: MutationOptions): Promise<string>;
+    updateFields(collection: string, fields: RawField[], opts?: MutationOptions): Promise<string[]>;
     deleteField(collection: string, field: string, opts?: MutationOptions): Promise<void>;
     addColumnToTable(table: Knex.CreateTableBuilder, field: RawField | Field, alter?: Column | null): void;
 }