@directus/api 13.2.0 → 14.0.1

package/dist/services/versions.js

@@ -0,0 +1,238 @@
+import { Action } from '@directus/constants';
+import { InvalidPayloadError, UnprocessableContentError } from '@directus/errors';
+import Joi from 'joi';
+import { assign, pick } from 'lodash-es';
+import objectHash from 'object-hash';
+import { getCache } from '../cache.js';
+import getDatabase from '../database/index.js';
+import emitter from '../emitter.js';
+import { shouldClearCache } from '../utils/should-clear-cache.js';
+import { ActivityService } from './activity.js';
+import { AuthorizationService } from './authorization.js';
+import { ItemsService } from './items.js';
+import { PayloadService } from './payload.js';
+import { RevisionsService } from './revisions.js';
+export class VersionsService extends ItemsService {
+    authorizationService;
+    constructor(options) {
+        super('directus_versions', options);
+        this.authorizationService = new AuthorizationService({
+            accountability: this.accountability,
+            knex: this.knex,
+            schema: this.schema,
+        });
+    }
+    async validateCreateData(data) {
+        if (!data['key'])
+            throw new InvalidPayloadError({ reason: `"key" is required` });
+        // Reserves the "main" version key for the version query parameter
+        if (data['key'] === 'main')
+            throw new InvalidPayloadError({ reason: `"main" is a reserved version key` });
+        if (!data['collection']) {
+            throw new InvalidPayloadError({ reason: `"collection" is required` });
+        }
+        if (!data['item'])
+            throw new InvalidPayloadError({ reason: `"item" is required` });
+        const { CollectionsService } = await import('./collections.js');
+        const collectionsService = new CollectionsService({
+            accountability: null,
+            knex: this.knex,
+            schema: this.schema,
+        });
+        const existingCollection = await collectionsService.readOne(data['collection']);
+        if (!existingCollection.meta?.versioning) {
+            throw new UnprocessableContentError({
+                reason: `Content Versioning is not enabled for collection "${data['collection']}"`,
+            });
+        }
+        const existingVersions = await super.readByQuery({
+            aggregate: { count: ['*'] },
+            filter: { key: { _eq: data['key'] }, collection: { _eq: data['collection'] }, item: { _eq: data['item'] } },
+        });
+        if (existingVersions[0]['count'] > 0) {
+            throw new UnprocessableContentError({
+                reason: `Version "${data['key']}" already exists for item "${data['item']}" in collection "${data['collection']}"`,
+            });
+        }
+        // will throw an error if the accountability does not have permission to read the item
+        await this.authorizationService.checkAccess('read', data['collection'], data['item']);
+    }
+    async getMainItem(collection, item, query) {
+        // will throw an error if the accountability does not have permission to read the item
+        await this.authorizationService.checkAccess('read', collection, item);
+        const itemsService = new ItemsService(collection, {
+            knex: this.knex,
+            accountability: this.accountability,
+            schema: this.schema,
+        });
+        return await itemsService.readOne(item, query);
+    }
+    async verifyHash(collection, item, hash) {
+        const mainItem = await this.getMainItem(collection, item);
+        const mainHash = objectHash(mainItem);
+        return { outdated: hash !== mainHash, mainHash };
+    }
+    async getVersionSavesById(id) {
+        const revisionsService = new RevisionsService({
+            knex: this.knex,
+            schema: this.schema,
+        });
+        const result = await revisionsService.readByQuery({
+            filter: { version: { _eq: id } },
+        });
+        return result.map((revision) => revision['delta']);
+    }
+    async getVersionSaves(key, collection, item) {
+        const filter = {
+            key: { _eq: key },
+            collection: { _eq: collection },
+        };
+        if (item) {
+            filter['item'] = { _eq: item };
+        }
+        const versions = await this.readByQuery({ filter });
+        if (!versions?.[0])
+            return null;
+        const saves = await this.getVersionSavesById(versions[0]['id']);
+        return saves;
+    }
+    async createOne(data, opts) {
+        await this.validateCreateData(data);
+        const mainItem = await this.getMainItem(data['collection'], data['item']);
+        data['hash'] = objectHash(mainItem);
+        return super.createOne(data, opts);
+    }
+    async createMany(data, opts) {
+        if (!Array.isArray(data)) {
+            throw new InvalidPayloadError({ reason: 'Input should be an array of items' });
+        }
+        const keyCombos = new Set();
+        for (const item of data) {
+            await this.validateCreateData(item);
+            const keyCombo = `${item['key']}-${item['collection']}-${item['item']}`;
+            if (keyCombos.has(keyCombo)) {
+                throw new UnprocessableContentError({
+                    reason: `Cannot create multiple versions on "${item['item']}" in collection "${item['collection']}" with the same key "${item['key']}"`,
+                });
+            }
+            keyCombos.add(keyCombo);
+            const mainItem = await this.getMainItem(item['collection'], item['item']);
+            item['hash'] = objectHash(mainItem);
+        }
+        return super.createMany(data, opts);
+    }
+    async updateMany(keys, data, opts) {
+        // Only allow updates on "key" and "name" fields
+        const versionUpdateSchema = Joi.object({
+            key: Joi.string(),
+            name: Joi.string().allow(null).optional(),
+        });
+        const { error } = versionUpdateSchema.validate(data);
+        if (error)
+            throw new InvalidPayloadError({ reason: error.message });
+        if ('key' in data) {
+            // Reserves the "main" version key for the version query parameter
+            if (data['key'] === 'main')
+                throw new InvalidPayloadError({ reason: `"main" is a reserved version key` });
+            const keyCombos = new Set();
+            for (const pk of keys) {
+                const { collection, item } = await this.readOne(pk, { fields: ['collection', 'item'] });
+                const keyCombo = `${data['key']}-${collection}-${item}`;
+                if (keyCombos.has(keyCombo)) {
+                    throw new UnprocessableContentError({
+                        reason: `Cannot update multiple versions on "${item}" in collection "${collection}" to the same key "${data['key']}"`,
+                    });
+                }
+                keyCombos.add(keyCombo);
+                const existingVersions = await super.readByQuery({
+                    aggregate: { count: ['*'] },
+                    filter: { id: { _neq: pk }, key: { _eq: data['key'] }, collection: { _eq: collection }, item: { _eq: item } },
+                });
+                if (existingVersions[0]['count'] > 0) {
+                    throw new UnprocessableContentError({
+                        reason: `Version "${data['key']}" already exists for item "${item}" in collection "${collection}"`,
+                    });
+                }
+            }
+        }
+        return super.updateMany(keys, data, opts);
+    }
+    async save(key, data) {
+        const version = await super.readOne(key);
+        const payloadService = new PayloadService(this.collection, {
+            accountability: this.accountability,
+            knex: this.knex,
+            schema: this.schema,
+        });
+        const activityService = new ActivityService({
+            knex: this.knex,
+            schema: this.schema,
+        });
+        const revisionsService = new RevisionsService({
+            knex: this.knex,
+            schema: this.schema,
+        });
+        const activity = await activityService.createOne({
+            action: Action.VERSION_SAVE,
+            user: this.accountability?.user ?? null,
+            collection: version['collection'],
+            ip: this.accountability?.ip ?? null,
+            user_agent: this.accountability?.userAgent ?? null,
+            origin: this.accountability?.origin ?? null,
+            item: version['item'],
+        });
+        const revisionDelta = await payloadService.prepareDelta(data);
+        await revisionsService.createOne({
+            activity,
+            version: key,
+            collection: version['collection'],
+            item: version['item'],
+            data: revisionDelta,
+            delta: revisionDelta,
+        });
+        const { cache } = getCache();
+        if (shouldClearCache(cache, undefined, version['collection'])) {
+            cache.clear();
+        }
+        return data;
+    }
+    async promote(version, mainHash, fields) {
+        const { id, collection, item } = (await this.readOne(version));
+        // will throw an error if the accountability does not have permission to update the item
+        await this.authorizationService.checkAccess('update', collection, item);
+        const { outdated } = await this.verifyHash(collection, item, mainHash);
+        if (outdated) {
+            throw new UnprocessableContentError({
+                reason: `Main item has changed since this version was last updated`,
+            });
+        }
+        const saves = await this.getVersionSavesById(id);
+        const versionResult = assign({}, ...saves);
+        const payloadToUpdate = fields ? pick(versionResult, fields) : versionResult;
+        const itemsService = new ItemsService(collection, {
+            accountability: this.accountability,
+            schema: this.schema,
+        });
+        const payloadAfterHooks = await emitter.emitFilter(['items.promote', `${collection}.items.promote`], payloadToUpdate, {
+            collection,
+            item,
+            version,
+        }, {
+            database: getDatabase(),
+            schema: this.schema,
+            accountability: this.accountability,
+        });
+        const updatedItemKey = await itemsService.updateOne(item, payloadAfterHooks);
+        emitter.emitAction(['items.promote', `${collection}.items.promote`], {
+            payload: payloadAfterHooks,
+            collection,
+            item: updatedItemKey,
+            version,
+        }, {
+            database: getDatabase(),
+            schema: this.schema,
+            accountability: this.accountability,
+        });
+        return updatedItemKey;
+    }
+}

package/dist/types/collection.d.ts

@@ -7,6 +7,7 @@ export type CollectionMeta = {
     singleton: boolean;
     icon: string | null;
     translations: Record<string, string>;
+    versioning: boolean;
     item_duplication_fields: string[] | null;
     accountability: 'all' | 'accountability' | null;
     group: string | null;

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

@@ -18,7 +18,7 @@ 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): {
+export declare function applySort(knex: Knex, schema: SchemaOverview, rootQuery: Knex.QueryBuilder, query: Query, collection: string, aliasMap: AliasMap, returnRecords?: boolean): {
     sortRecords: {
         order: "asc" | "desc";
         column: any;

package/dist/utils/apply-query.js

@@ -24,7 +24,7 @@ export default function applyQuery(knex, collection, dbQuery, query, schema, opt
         applyOffset(knex, dbQuery, query.limit * (query.page - 1));
     }
     if (query.sort && !options?.isInnerQuery && !options?.hasMultiRelationalSort) {
-        const sortResult = applySort(knex, schema, dbQuery, query.sort, collection, aliasMap);
+        const sortResult = applySort(knex, schema, dbQuery, query, collection, aliasMap);
         if (!hasJoins) {
             hasJoins = sortResult.hasJoins;
         }
@@ -128,7 +128,9 @@ function addJoin({ path, collection, aliasMap, rootQuery, schema, relations, kne
         }
     }
 }
-export function applySort(knex, schema, rootQuery, rootSort, collection, aliasMap, returnRecords = false) {
+export function applySort(knex, schema, rootQuery, query, collection, aliasMap, returnRecords = false) {
+    const rootSort = query.sort;
+    const aggregate = query?.aggregate;
     const relations = schema.relations;
     let hasJoins = false;
     let hasMultiRelationalSort = false;
@@ -141,6 +143,32 @@ export function applySort(knex, schema, rootQuery, rootSort, collection, aliasMa
         if (column[0].startsWith('-')) {
             column[0] = column[0].substring(1);
         }
+        // Is the column name one of the aggregate functions used in the query if there is any?
+        if (Object.keys(aggregate ?? {}).includes(column[0])) {
+            // If so, return the column name without the order prefix
+            const operation = column[0];
+            // Get the field for the aggregate function
+            const field = column[1];
+            // If the operation is countAll there is no field.
+            if (operation === 'countAll') {
+                return {
+                    order,
+                    column: 'countAll',
+                };
+            }
+            // If the operation is a root count there is no field.
+            if (operation === 'count' && (field === '*' || !field)) {
+                return {
+                    order,
+                    column: 'count',
+                };
+            }
+            // Return the column name with the operation and field name
+            return {
+                order,
+                column: returnRecords ? column[0] : `${operation}->${field}`,
+            };
+        }
         if (column.length === 1) {
             const pathRoot = column[0].split(':')[0];
             const { relation, relationType } = getRelationInfo(relations, collection, pathRoot);

package/dist/utils/delete-from-require-cache.d.ts

@@ -0,0 +1 @@
+export declare function deleteFromRequireCache(modulePath: string): void;

package/dist/utils/delete-from-require-cache.js

@@ -0,0 +1,5 @@
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+export function deleteFromRequireCache(modulePath) {
+    delete require.cache[require.resolve(modulePath)];
+}

package/dist/utils/get-service.js

@@ -1,4 +1,4 @@
-import { ActivityService, DashboardsService, FilesService, FlowsService, FoldersService, ItemsService, NotificationsService, OperationsService, PanelsService, PermissionsService, PresetsService, RevisionsService, RolesService, SettingsService, SharesService, UsersService, WebhooksService, } from '../services/index.js';
+import { ActivityService, DashboardsService, FilesService, FlowsService, FoldersService, ItemsService, NotificationsService, OperationsService, PanelsService, PermissionsService, PresetsService, RevisionsService, RolesService, SettingsService, SharesService, UsersService, VersionsService, WebhooksService, } from '../services/index.js';
 /**
  * Select the correct service for the given collection. This allows the individual services to run
  * their custom checks (f.e. it allows UsersService to prevent updating TFA secret from outside)
@@ -43,6 +43,8 @@ export function getService(collection, opts) {
             return new UsersService(opts);
         case 'directus_webhooks':
             return new WebhooksService(opts);
+        case 'directus_versions':
+            return new VersionsService(opts);
         default:
             return new ItemsService(collection, opts);
     }

package/dist/utils/import-file-url.d.ts

@@ -0,0 +1,5 @@
+interface ImportOptions {
+    fresh?: boolean;
+}
+export declare function importFileUrl(url: string, root: string, options?: ImportOptions): Promise<any>;
+export {};

package/dist/utils/import-file-url.js

@@ -0,0 +1,6 @@
+import { dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { pathToRelativeUrl } from '@directus/utils/node';
+export function importFileUrl(url, root, options = {}) {
+    return import(`./${pathToRelativeUrl(url, dirname(fileURLToPath(root)))}${options.fresh ? `?t=${Date.now()}` : ''}`);
+}

package/dist/utils/job-queue.d.ts

@@ -1,9 +1,8 @@
-type Job = () => Promise<void> | void;
+import type { PromiseCallback } from '@directus/types';
 export declare class JobQueue {
     private running;
     private jobs;
     constructor();
-    enqueue(job: Job): void;
+    enqueue(job: PromiseCallback): void;
     private run;
 }
-export {};

package/dist/utils/redact-object.d.ts

@@ -19,5 +19,5 @@ export declare function redactObject(input: UnknownObject, redact: {
 /**
  * Replace values and extract Error objects for use with JSON.stringify()
  */
-export declare function getReplacer(replacement: Replacement, values?: Values): (_key: string, value: unknown) => unknown;
+export declare function getReplacer(replacement: Replacement, values?: Values): (_key: string, value: unknown) => any;
 export {};

package/dist/utils/redact-object.js

@@ -84,31 +84,44 @@ export function getReplacer(replacement, values) {
     const filteredValues = values
         ? Object.entries(values).filter(([_k, v]) => typeof v === 'string' && v.length > 0)
         : [];
-    const seen = new WeakSet();
-    return (_key, value) => {
-        // Skip circular values
-        if (isObject(value)) {
-            if (seen.has(value)) {
-                return;
+    const replacer = (seen) => {
+        return function (_key, value) {
+            if (value instanceof Error) {
+                return {
+                    name: value.name,
+                    message: value.message,
+                    stack: value.stack,
+                    cause: value.cause,
+                };
             }
-            seen.add(value);
-        }
-        if (value instanceof Error) {
-            return {
-                name: value.name,
-                message: value.message,
-                stack: value.stack,
-                cause: value.cause,
-            };
-        }
-        if (!values || filteredValues.length === 0 || typeof value !== 'string')
-            return value;
-        let finalValue = value;
-        for (const [redactKey, valueToRedact] of filteredValues) {
-            if (finalValue.includes(valueToRedact)) {
-                finalValue = finalValue.replace(new RegExp(valueToRedact, 'g'), replacement(redactKey));
+            if (value !== null && typeof value === 'object') {
+                if (seen.has(value)) {
+                    return '[Circular]';
+                }
+                seen.add(value);
+                const newValue = Array.isArray(value) ? [] : {};
+                for (const [key2, value2] of Object.entries(value)) {
+                    if (typeof value2 === 'string') {
+                        newValue[key2] = value2;
+                    }
+                    else {
+                        newValue[key2] = replacer(seen)(key2, value2);
+                    }
+                }
+                seen.delete(value);
+                return newValue;
             }
-        }
-        return finalValue;
+            if (!values || filteredValues.length === 0 || typeof value !== 'string')
+                return value;
+            let finalValue = value;
+            for (const [redactKey, valueToRedact] of filteredValues) {
+                if (finalValue.includes(valueToRedact)) {
+                    finalValue = finalValue.replace(new RegExp(valueToRedact, 'g'), replacement(redactKey));
+                }
+            }
+            return finalValue;
+        };
     };
+    const seen = new WeakSet();
+    return replacer(seen);
 }

package/dist/utils/sanitize-query.js

@@ -46,6 +46,9 @@ export function sanitizeQuery(rawQuery, accountability) {
     if (rawQuery['search'] && typeof rawQuery['search'] === 'string') {
         query.search = rawQuery['search'];
     }
+    if (rawQuery['version']) {
+        query.version = rawQuery['version'];
+    }
     if (rawQuery['export']) {
         query.export = rawQuery['export'];
     }

package/dist/utils/validate-query.js

@@ -17,6 +17,7 @@ const querySchema = Joi.object({
     meta: Joi.array().items(Joi.string().valid('total_count', 'filter_count')),
     search: Joi.string(),
     export: Joi.string().valid('csv', 'json', 'xml', 'yaml'),
+    version: Joi.string(),
     aggregate: Joi.object(),
     deep: Joi.object(),
     alias: Joi.object(),

package/dist/worker-pool.js

@@ -1,3 +1,4 @@
+import os from 'node:os';
 import Tinypool from 'tinypool';
 let workerPool;
 export function getWorkerPool() {
@@ -6,6 +7,13 @@ export function getWorkerPool() {
             minThreads: 0,
             maxQueue: 'auto',
         });
+        // TODO Workaround currently required for failing CPU count on ARM in Tinypool,
+        //      remove again once fixed upstream
+        if (workerPool.options.maxThreads === 0) {
+            const availableParallelism = os.availableParallelism();
+            workerPool.options.maxThreads = availableParallelism;
+            workerPool.options.maxQueue = availableParallelism ** 2;
+        }
     }
     return workerPool;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@directus/api",
-  "version": "13.2.0",
+  "version": "14.0.1",
   "description": "Directus is a real-time API and App dashboard for managing SQL database content",
   "keywords": [
     "directus",
@@ -60,12 +60,12 @@
   "dependencies": {
     "@authenio/samlify-node-xmllint": "2.0.0",
     "@aws-sdk/client-ses": "3.332.0",
-    "@directus/format-title": "10.0.0",
+    "@directus/format-title": "10.1.0",
     "@godaddy/terminus": "4.12.0",
     "@rollup/plugin-alias": "5.0.0",
     "@rollup/plugin-node-resolve": "15.0.2",
     "@rollup/plugin-virtual": "3.0.1",
-    "argon2": "0.30.3",
+    "argon2": "0.31.1",
     "async": "3.2.4",
     "axios": "1.4.0",
     "busboy": "1.6.0",
@@ -89,9 +89,10 @@
     "express": "4.18.2",
     "flat": "5.0.2",
     "fs-extra": "11.1.1",
-    "graphql": "16.6.0",
+    "glob-to-regexp": "0.4.1",
+    "graphql": "16.8.1",
     "graphql-compose": "9.0.10",
-    "graphql-ws": "5.12.0",
+    "graphql-ws": "5.14.1",
     "helmet": "7.0.0",
     "icc": "3.0.0",
     "inquirer": "9.2.4",
@@ -131,7 +132,7 @@
     "rollup": "3.22.0",
     "samlify": "2.8.10",
     "sanitize-html": "2.10.0",
-    "sharp": "0.32.5",
+    "sharp": "0.32.6",
     "snappy": "7.2.2",
     "stream-json": "1.7.5",
     "strip-bom-stream": "5.0.0",
@@ -140,26 +141,26 @@
     "uuid": "9.0.0",
     "uuid-validate": "0.0.3",
     "wellknown": "0.5.0",
-    "ws": "8.12.1",
-    "zod": "3.21.4",
+    "ws": "8.14.2",
+    "zod": "3.22.4",
     "zod-validation-error": "1.0.1",
-    "@directus/app": "10.9.1",
-    "@directus/constants": "11.0.0",
-    "@directus/errors": "0.1.0",
-    "@directus/extensions": "0.0.1",
-    "@directus/extensions-sdk": "10.1.12",
-    "@directus/pressure": "1.0.11",
+    "@directus/app": "10.11.0",
+    "@directus/constants": "11.0.1",
+    "@directus/errors": "0.2.0",
+    "@directus/extensions": "0.1.1",
+    "@directus/extensions-sdk": "10.1.14",
+    "@directus/pressure": "1.0.12",
     "@directus/schema": "11.0.0",
-    "@directus/specs": "10.2.0",
-    "@directus/storage": "10.0.6",
-    "@directus/storage-driver-azure": "10.0.12",
-    "@directus/storage-driver-cloudinary": "10.0.12",
-    "@directus/storage-driver-gcs": "10.0.12",
-    "@directus/storage-driver-local": "10.0.12",
-    "@directus/storage-driver-s3": "10.0.12",
-    "@directus/storage-driver-supabase": "1.0.4",
-    "@directus/utils": "11.0.0",
-    "@directus/validation": "0.0.7"
+    "@directus/specs": "10.2.1",
+    "@directus/storage": "10.0.7",
+    "@directus/storage-driver-azure": "10.0.13",
+    "@directus/storage-driver-cloudinary": "10.0.13",
+    "@directus/storage-driver-gcs": "10.0.13",
+    "@directus/storage-driver-local": "10.0.13",
+    "@directus/storage-driver-s3": "10.0.13",
+    "@directus/storage-driver-supabase": "1.0.5",
+    "@directus/utils": "11.0.1",
+    "@directus/validation": "0.0.8"
   },
   "devDependencies": {
     "@ngneat/falso": "6.4.0",
@@ -177,11 +178,11 @@
     "@types/express-serve-static-core": "4.17.35",
     "@types/flat": "5.0.2",
     "@types/fs-extra": "11.0.1",
+    "@types/glob-to-regexp": "0.4.3",
     "@types/inquirer": "9.0.3",
     "@types/js-yaml": "4.0.5",
     "@types/json2csv": "5.0.3",
     "@types/jsonwebtoken": "9.0.2",
-    "@types/keyv": "4.2.0",
     "@types/ldapjs": "2.2.5",
     "@types/lodash-es": "4.17.7",
     "@types/marked": "4.3.0",
@@ -199,7 +200,7 @@
     "@types/uuid": "9.0.1",
     "@types/uuid-validate": "0.0.1",
     "@types/wellknown": "0.5.4",
-    "@types/ws": "8.5.4",
+    "@types/ws": "8.5.8",
     "@vitest/coverage-c8": "0.31.1",
     "copyfiles": "2.4.1",
     "form-data": "4.0.0",
@@ -209,7 +210,7 @@
     "vitest": "0.31.1",
     "@directus/random": "0.2.3",
     "@directus/tsconfig": "1.0.1",
-    "@directus/types": "11.0.0"
+    "@directus/types": "11.0.1"
   },
   "optionalDependencies": {
     "@keyv/redis": "2.5.8",

package/dist/extensions/get-extensions.d.ts

@@ -1,47 +0,0 @@
-export declare const getExtensions: () => Promise<(({
-    path: string;
-    name: string;
-    version?: string;
-    host?: string;
-    local: boolean;
-} & {
-    type: "interface" | "display" | "layout" | "module" | "panel";
-    entrypoint: string;
-}) | ({
-    path: string;
-    name: string;
-    version?: string;
-    host?: string;
-    local: boolean;
-} & {
-    type: "endpoint" | "hook";
-    entrypoint: string;
-}) | ({
-    path: string;
-    name: string;
-    version?: string;
-    host?: string;
-    local: boolean;
-} & {
-    type: "operation";
-    entrypoint: {
-        app: string;
-        api: string;
-    };
-}) | ({
-    path: string;
-    name: string;
-    version?: string;
-    host?: string;
-    local: boolean;
-} & {
-    type: "bundle";
-    entrypoint: {
-        app: string;
-        api: string;
-    };
-    entries: {
-        type: "operation" | "interface" | "display" | "endpoint" | "layout" | "module" | "panel" | "hook";
-        name: string;
-    }[];
-}))[]>;

package/dist/extensions/get-extensions.js

@@ -1,9 +0,0 @@
-import { APP_EXTENSION_TYPES } from '@directus/extensions';
-import { getLocalExtensions, getPackageExtensions, resolvePackageExtensions } from '@directus/extensions/node';
-import env from '../env.js';
-export const getExtensions = async () => {
-    const packageExtensions = await getPackageExtensions(env['PACKAGE_FILE_LOCATION']);
-    const localPackageExtensions = await resolvePackageExtensions(env['EXTENSIONS_PATH']);
-    const localExtensions = await getLocalExtensions(env['EXTENSIONS_PATH']);
-    return [...packageExtensions, ...localPackageExtensions, ...localExtensions].filter((extension) => env['SERVE_APP'] || APP_EXTENSION_TYPES.includes(extension.type) === false);
-};