@directus/api 14.0.2 → 14.1.1

package/dist/services/server.js

@@ -34,6 +34,10 @@ export class ServerService {
                 'project_logo',
                 'project_color',
                 'default_appearance',
+                'default_theme_light',
+                'default_theme_dark',
+                'theme_light_overrides',
+                'theme_dark_overrides',
                 'default_language',
                 'public_foreground',
                 'public_background',

package/dist/services/specifications.d.ts

@@ -2,20 +2,14 @@ import type { Accountability, SchemaOverview } from '@directus/types';
 import type { Knex } from 'knex';
 import type { OpenAPIObject } from 'openapi3-ts/oas30';
 import type { AbstractServiceOptions } from '../types/index.js';
-import { CollectionsService } from './collections.js';
-import { FieldsService } from './fields.js';
 import { GraphQLService } from './graphql/index.js';
-import { RelationsService } from './relations.js';
 export declare class SpecificationService {
     accountability: Accountability | null;
     knex: Knex;
     schema: SchemaOverview;
-    fieldsService: FieldsService;
-    collectionsService: CollectionsService;
-    relationsService: RelationsService;
     oas: OASSpecsService;
     graphql: GraphQLSpecsService;
-    constructor(options: AbstractServiceOptions);
+    constructor({ accountability, knex, schema }: AbstractServiceOptions);
 }
 interface SpecificationSubService {
     generate: (_?: any) => Promise<any>;
@@ -24,15 +18,8 @@ declare class OASSpecsService implements SpecificationSubService {
     accountability: Accountability | null;
     knex: Knex;
     schema: SchemaOverview;
-    fieldsService: FieldsService;
-    collectionsService: CollectionsService;
-    relationsService: RelationsService;
-    constructor(options: AbstractServiceOptions, { fieldsService, collectionsService, relationsService, }: {
-        fieldsService: FieldsService;
-        collectionsService: CollectionsService;
-        relationsService: RelationsService;
-    });
-    generate(): Promise<OpenAPIObject>;
+    constructor({ knex, schema, accountability }: AbstractServiceOptions);
+    generate(host?: string): Promise<OpenAPIObject>;
     private generateTags;
     private generatePaths;
     private generateComponents;

package/dist/services/specifications.js

@@ -6,57 +6,39 @@ import getDatabase from '../database/index.js';
 import env from '../env.js';
 import { getRelationType } from '../utils/get-relation-type.js';
 import { version } from '../utils/package.js';
-import { CollectionsService } from './collections.js';
-import { FieldsService } from './fields.js';
 import { GraphQLService } from './graphql/index.js';
-import { RelationsService } from './relations.js';
+import { reduceSchema } from '../utils/reduce-schema.js';
 export class SpecificationService {
     accountability;
     knex;
     schema;
-    fieldsService;
-    collectionsService;
-    relationsService;
     oas;
     graphql;
-    constructor(options) {
-        this.accountability = options.accountability || null;
-        this.knex = options.knex || getDatabase();
-        this.schema = options.schema;
-        this.fieldsService = new FieldsService(options);
-        this.collectionsService = new CollectionsService(options);
-        this.relationsService = new RelationsService(options);
-        this.oas = new OASSpecsService(options, {
-            fieldsService: this.fieldsService,
-            collectionsService: this.collectionsService,
-            relationsService: this.relationsService,
-        });
-        this.graphql = new GraphQLSpecsService(options);
+    constructor({ accountability, knex, schema }) {
+        this.accountability = accountability || null;
+        this.knex = knex || getDatabase();
+        this.schema = schema;
+        this.oas = new OASSpecsService({ knex, schema, accountability });
+        this.graphql = new GraphQLSpecsService({ knex, schema });
     }
 }
 class OASSpecsService {
     accountability;
     knex;
     schema;
-    fieldsService;
-    collectionsService;
-    relationsService;
-    constructor(options, { fieldsService, collectionsService, relationsService, }) {
-        this.accountability = options.accountability || null;
-        this.knex = options.knex || getDatabase();
-        this.schema = options.schema;
-        this.fieldsService = fieldsService;
-        this.collectionsService = collectionsService;
-        this.relationsService = relationsService;
+    constructor({ knex, schema, accountability }) {
+        this.accountability = accountability || null;
+        this.knex = knex || getDatabase();
+        this.schema =
+            this.accountability?.admin === true ? schema : reduceSchema(schema, accountability?.permissions || null);
     }
-    async generate() {
-        const collections = await this.collectionsService.readByQuery();
-        const fields = await this.fieldsService.readAll();
-        const relations = (await this.relationsService.readAll());
+    async generate(host) {
         const permissions = this.accountability?.permissions ?? [];
-        const tags = await this.generateTags(collections);
+        const tags = await this.generateTags();
         const paths = await this.generatePaths(permissions, tags);
-        const components = await this.generateComponents(collections, fields, relations, tags);
+        const components = await this.generateComponents(tags);
+        const isDefaultPublicUrl = env['PUBLIC_URL'] === '/';
+        const url = isDefaultPublicUrl && host ? host : env['PUBLIC_URL'];
         const spec = {
             openapi: '3.0.1',
             info: {
@@ -66,7 +48,7 @@ class OASSpecsService {
             },
             servers: [
                 {
-                    url: env['PUBLIC_URL'],
+                    url,
                     description: 'Your current Directus instance.',
                 },
             ],
@@ -78,11 +60,17 @@ class OASSpecsService {
             spec.components = components;
         return spec;
     }
-    async generateTags(collections) {
+    async generateTags() {
         const systemTags = cloneDeep(spec.tags);
+        const collections = Object.values(this.schema.collections);
         const tags = [];
-        // System tags that don't have an associated collection are always readable to the user
         for (const systemTag of systemTags) {
+            // Check if necessary authentication level is given
+            if (systemTag['x-authentication'] === 'admin' && !this.accountability?.admin)
+                continue;
+            if (systemTag['x-authentication'] === 'user' && !this.accountability?.user)
+                continue;
+            // Remaining system tags that don't have an associated collection are publicly available
             if (!systemTag['x-collection']) {
                 tags.push(systemTag);
             }
@@ -103,8 +91,8 @@ class OASSpecsService {
                     name: 'Items' + formatTitle(collection.collection).replace(/ /g, ''),
                     'x-collection': collection.collection,
                 };
-                if (collection.meta?.note) {
-                    tag.description = collection.meta.note;
+                if (collection.note) {
+                    tag.description = collection.note;
                 }
                 tags.push(tag);
             }
@@ -256,33 +244,38 @@ class OASSpecsService {
         }
         return paths;
     }
-    async generateComponents(collections, fields, relations, tags) {
+    async generateComponents(tags) {
+        if (!tags)
+            return;
         let components = cloneDeep(spec.components);
         if (!components)
             components = {};
         components.schemas = {};
-        // Always includes the schemas with these names
-        if (spec.components?.schemas !== null) {
-            for (const schemaName of OAS_REQUIRED_SCHEMAS) {
-                if (spec.components.schemas[schemaName] !== null) {
-                    components.schemas[schemaName] = cloneDeep(spec.components.schemas[schemaName]);
-                }
+        const tagSchemas = tags.reduce((schemas, tag) => [...schemas, ...(tag['x-schemas'] ? tag['x-schemas'] : [])], []);
+        const requiredSchemas = [...OAS_REQUIRED_SCHEMAS, ...tagSchemas];
+        for (const [name, schema] of Object.entries(spec.components?.schemas ?? {})) {
+            if (requiredSchemas.includes(name)) {
+                const collection = spec.tags?.find((tag) => tag.name === name)?.['x-collection'];
+                components.schemas[name] = {
+                    ...cloneDeep(schema),
+                    ...(collection && { 'x-collection': collection }),
+                };
             }
         }
-        if (!tags)
-            return;
+        const collections = Object.values(this.schema.collections);
         for (const collection of collections) {
             const tag = tags.find((tag) => tag['x-collection'] === collection.collection);
             if (!tag)
                 continue;
             const isSystem = collection.collection.startsWith('directus_');
-            const fieldsInCollection = fields.filter((field) => field.collection === collection.collection);
+            const fieldsInCollection = Object.values(collection.fields);
             if (isSystem) {
                 const schemaComponent = cloneDeep(spec.components.schemas[tag.name]);
                 schemaComponent.properties = {};
+                schemaComponent['x-collection'] = collection.collection;
                 for (const field of fieldsInCollection) {
                     schemaComponent.properties[field.field] =
-                        cloneDeep(spec.components.schemas[tag.name].properties[field.field]) || this.generateField(field, relations, tags, fields);
+                        cloneDeep(spec.components.schemas[tag.name].properties[field.field]) || this.generateField(collection.collection, field, tags);
                 }
                 components.schemas[tag.name] = schemaComponent;
             }
@@ -293,7 +286,7 @@ class OASSpecsService {
                     'x-collection': collection.collection,
                 };
                 for (const field of fieldsInCollection) {
-                    schemaComponent.properties[field.field] = this.generateField(field, relations, tags, fields);
+                    schemaComponent.properties[field.field] = this.generateField(collection.collection, field, tags);
                 }
                 components.schemas[tag.name] = schemaComponent;
             }
@@ -316,16 +309,14 @@ class OASSpecsService {
                 return 'read';
         }
     }
-    generateField(field, relations, tags, fields) {
+    generateField(collection, field, tags) {
         let propertyObject = {};
-        if (field.schema && 'is_nullable' in field.schema) {
-            propertyObject.nullable = field.schema.is_nullable;
+        propertyObject.nullable = field.nullable;
+        if (field.note) {
+            propertyObject.description = field.note;
         }
-        if (field.meta?.note) {
-            propertyObject.description = field.meta.note;
-        }
-        const relation = relations.find((relation) => (relation.collection === field.collection && relation.field === field.field) ||
-            (relation.related_collection === field.collection && relation.meta?.one_field === field.field));
+        const relation = this.schema.relations.find((relation) => (relation.collection === collection && relation.field === field.field) ||
+            (relation.related_collection === collection && relation.meta?.one_field === field.field));
         if (!relation) {
             propertyObject = {
                 ...propertyObject,
@@ -336,13 +327,17 @@ class OASSpecsService {
             const relationType = getRelationType({
                 relation,
                 field: field.field,
-                collection: field.collection,
+                collection: collection,
             });
             if (relationType === 'm2o') {
                 const relatedTag = tags.find((tag) => tag['x-collection'] === relation.related_collection);
-                const relatedPrimaryKeyField = fields.find((field) => field.collection === relation.related_collection && field.schema?.is_primary_key);
-                if (!relatedTag || !relatedPrimaryKeyField)
+                if (!relatedTag ||
+                    !relation.related_collection ||
+                    relation.related_collection in this.schema.collections === false) {
                     return propertyObject;
+                }
+                const relatedCollection = this.schema.collections[relation.related_collection];
+                const relatedPrimaryKeyField = relatedCollection.fields[relatedCollection.primary];
                 propertyObject.oneOf = [
                     {
                         ...this.fieldTypes[relatedPrimaryKeyField.type],
@@ -354,7 +349,11 @@ class OASSpecsService {
             }
             else if (relationType === 'o2m') {
                 const relatedTag = tags.find((tag) => tag['x-collection'] === relation.collection);
-                const relatedPrimaryKeyField = fields.find((field) => field.collection === relation.collection && field.schema?.is_primary_key);
+                if (!relatedTag || !relation.related_collection || relation.collection in this.schema.collections === false) {
+                    return propertyObject;
+                }
+                const relatedCollection = this.schema.collections[relation.collection];
+                const relatedPrimaryKeyField = relatedCollection.fields[relatedCollection.primary];
                 if (!relatedTag || !relatedPrimaryKeyField)
                     return propertyObject;
                 propertyObject.type = 'array';

package/dist/storage/register-drivers.js

@@ -1,7 +1,6 @@
-import { getEnv } from '../env.js';
+import env from '../env.js';
 import { getStorageDriver } from './get-storage-driver.js';
 export const registerDrivers = async (storage) => {
-    const env = getEnv();
     const usedDrivers = [];
     for (const [key, value] of Object.entries(env)) {
         if ((key.startsWith('STORAGE_') && key.endsWith('_DRIVER')) === false)

package/dist/storage/register-locations.js

@@ -1,8 +1,7 @@
 import { toArray } from '@directus/utils';
-import { getEnv } from '../env.js';
+import env from '../env.js';
 import { getConfigFromEnv } from '../utils/get-config-from-env.js';
 export const registerLocations = async (storage) => {
-    const env = getEnv();
     const locations = toArray(env['STORAGE_LOCATIONS']);
     locations.forEach((location) => {
         location = location.trim();

package/dist/types/services.d.ts

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

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

@@ -1,8 +1,8 @@
 interface AuthProvider {
-    label: string;
     name: string;
     driver: string;
     icon?: string;
+    label?: string;
 }
 export declare function getAuthProviders(): AuthProvider[];
 export {};

package/dist/utils/get-config-from-env.js

@@ -1,8 +1,7 @@
 import camelcase from 'camelcase';
 import { set } from 'lodash-es';
-import { getEnv } from '../env.js';
+import env from '../env.js';
 export function getConfigFromEnv(prefix, omitPrefix, type = 'camelcase') {
-    const env = getEnv();
     const config = {};
     for (const [key, value] of Object.entries(env)) {
         if (key.toLowerCase().startsWith(prefix.toLowerCase()) === false)

package/dist/utils/merge-permissions.js

@@ -1,4 +1,4 @@
-import { flatten, intersection, isEqual, merge, omit } from 'lodash-es';
+import { flatten, intersection, isEmpty, merge, omit } from 'lodash-es';
 export function mergePermissions(strategy, ...permissions) {
     const allPermissions = flatten(permissions);
     const mergedPermissions = allPermissions
@@ -27,15 +27,11 @@ export function mergePermission(strategy, currentPerm, newPerm) {
             };
         }
         else if (currentPerm.permissions) {
-            // Empty {} supersedes other permissions in _OR merge
-            if (strategy === 'or' && (isEqual(currentPerm.permissions, {}) || isEqual(newPerm.permissions, {}))) {
-                permissions = {};
-            }
-            else {
-                permissions = {
-                    [logicalKey]: [currentPerm.permissions, newPerm.permissions],
-                };
-            }
+            permissions = {
+                [logicalKey]: strategy === 'or'
+                    ? [currentPerm.permissions, newPerm.permissions].filter((p) => !isEmpty(p))
+                    : [currentPerm.permissions, newPerm.permissions],
+            };
         }
         else {
             permissions = {
@@ -53,15 +49,11 @@ export function mergePermission(strategy, currentPerm, newPerm) {
             };
         }
         else if (currentPerm.validation) {
-            // Empty {} supersedes other validations in _OR merge
-            if (strategy === 'or' && (isEqual(currentPerm.validation, {}) || isEqual(newPerm.validation, {}))) {
-                validation = {};
-            }
-            else {
-                validation = {
-                    [logicalKey]: [currentPerm.validation, newPerm.validation],
-                };
-            }
+            validation = {
+                [logicalKey]: strategy === 'or'
+                    ? [currentPerm.validation, newPerm.validation].filter((p) => !isEmpty(p))
+                    : [currentPerm.validation, newPerm.validation],
+            };
         }
         else {
             validation = {

package/dist/utils/sanitize-query.js

@@ -1,11 +1,10 @@
 import { parseFilter, parseJSON } from '@directus/utils';
 import { flatten, get, isPlainObject, merge, set } from 'lodash-es';
-import { getEnv } from '../env.js';
+import env from '../env.js';
 import logger from '../logger.js';
 import { Meta } from '../types/index.js';
 export function sanitizeQuery(rawQuery, accountability) {
     const query = {};
-    const env = getEnv();
     const hasMaxLimit = 'QUERY_LIMIT_MAX' in env &&
         Number(env['QUERY_LIMIT_MAX']) >= 0 &&
         !Number.isNaN(Number(env['QUERY_LIMIT_MAX'])) &&

package/dist/utils/should-clear-cache.js

@@ -1,4 +1,4 @@
-import { getEnv } from '../env.js';
+import env from '../env.js';
 /**
  * Check whether cache should be cleared
  *
@@ -7,7 +7,6 @@ import { getEnv } from '../env.js';
  * @param collection Collection name to check if cache purging should be ignored
  */
 export function shouldClearCache(cache, opts, collection) {
-    const env = getEnv();
     if (env['CACHE_AUTO_PURGE']) {
         if (collection && env['CACHE_AUTO_PURGE_IGNORE_LIST'].includes(collection)) {
             return false;

package/dist/utils/should-skip-cache.js

@@ -1,14 +1,13 @@
-import { getEnv } from '../env.js';
-import { Url } from './url.js';
-import url from 'url';
 import { getEndpoint } from '@directus/utils';
+import url from 'url';
+import env from '../env.js';
+import { Url } from './url.js';
 /**
  * Whether to skip caching for the current request
  *
  * @param req Express request object
  */
 export function shouldSkipCache(req) {
-    const env = getEnv();
     // Always skip cache for requests coming from the data studio based on Referer header
     const referer = req.get('Referer');
     if (referer) {

package/dist/utils/validate-env.js

@@ -1,7 +1,6 @@
-import { getEnv } from '../env.js';
+import env from '../env.js';
 import logger from '../logger.js';
 export function validateEnv(requiredKeys) {
-    const env = getEnv();
     for (const requiredKey of requiredKeys) {
         if (requiredKey in env === false) {
             logger.error(`"${requiredKey}" Environment Variable is missing.`);

package/dist/utils/validate-storage.js

@@ -1,9 +1,10 @@
-import env from '../env.js';
-import logger from '../logger.js';
-import { access } from 'node:fs/promises';
+import { toArray } from '@directus/utils';
 import { constants } from 'fs';
+import { access } from 'node:fs/promises';
 import path from 'path';
-import { toArray } from '@directus/utils';
+import env from '../env.js';
+import { getExtensionsPath } from '../extensions/lib/get-extensions-path.js';
+import logger from '../logger.js';
 export async function validateStorage() {
     if (env['DB_CLIENT'] === 'sqlite3') {
         try {
@@ -22,10 +23,12 @@ export async function validateStorage() {
             logger.warn(`Upload directory (${path.resolve(env['STORAGE_LOCAL_ROOT'])}) is not read/writeable!`);
         }
     }
-    try {
-        await access(env['EXTENSIONS_PATH'], constants.R_OK);
-    }
-    catch {
-        logger.warn(`Extensions directory (${path.resolve(env['EXTENSIONS_PATH'])}) is not readable!`);
+    if (!env['EXTENSIONS_LOCATION']) {
+        try {
+            await access(getExtensionsPath(), constants.R_OK);
+        }
+        catch {
+            logger.warn(`Extensions directory (${path.resolve(getExtensionsPath())}) is not readable!`);
+        }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@directus/api",
-  "version": "14.0.2",
+  "version": "14.1.1",
   "description": "Directus is a real-time API and App dashboard for managing SQL database content",
   "keywords": [
     "directus",
@@ -122,6 +122,7 @@
     "openid-client": "5.4.2",
     "ora": "6.3.1",
     "otplib": "12.0.1",
+    "p-queue": "7.4.1",
     "papaparse": "5.4.1",
     "pino": "8.14.1",
     "pino-http": "8.3.3",
@@ -144,23 +145,23 @@
     "ws": "8.14.2",
     "zod": "3.22.4",
     "zod-validation-error": "1.0.1",
-    "@directus/app": "10.12.0",
+    "@directus/app": "10.13.1",
     "@directus/constants": "11.0.1",
-    "@directus/extensions": "0.1.1",
+    "@directus/extensions": "0.2.0",
+    "@directus/extensions-sdk": "10.2.0",
     "@directus/errors": "0.2.0",
-    "@directus/extensions-sdk": "10.1.14",
-    "@directus/pressure": "1.0.12",
+    "@directus/pressure": "1.0.13",
     "@directus/schema": "11.0.0",
-    "@directus/specs": "10.2.1",
     "@directus/storage": "10.0.7",
-    "@directus/storage-driver-azure": "10.0.13",
-    "@directus/storage-driver-gcs": "10.0.13",
-    "@directus/storage-driver-cloudinary": "10.0.13",
-    "@directus/storage-driver-s3": "10.0.13",
-    "@directus/storage-driver-local": "10.0.13",
-    "@directus/storage-driver-supabase": "1.0.5",
-    "@directus/validation": "0.0.8",
-    "@directus/utils": "11.0.1"
+    "@directus/specs": "10.2.3",
+    "@directus/storage-driver-azure": "10.0.14",
+    "@directus/storage-driver-local": "10.0.14",
+    "@directus/storage-driver-cloudinary": "10.0.14",
+    "@directus/storage-driver-s3": "10.0.14",
+    "@directus/storage-driver-gcs": "10.0.14",
+    "@directus/storage-driver-supabase": "1.0.6",
+    "@directus/utils": "11.0.2",
+    "@directus/validation": "0.0.9"
   },
   "devDependencies": {
     "@ngneat/falso": "6.4.0",
@@ -210,7 +211,7 @@
     "vitest": "0.31.1",
     "@directus/random": "0.2.3",
     "@directus/tsconfig": "1.0.1",
-    "@directus/types": "11.0.1"
+    "@directus/types": "11.0.2"
   },
   "optionalDependencies": {
     "@keyv/redis": "2.5.8",

package/dist/__mocks__/cache.d.mts

@@ -1,5 +0,0 @@
-import type { Mock } from 'vitest';
-export declare const getCache: Mock;
-export declare const flushCaches: Mock;
-export declare const clearSystemCache: Mock;
-export declare const setSystemCache: Mock;

package/dist/__mocks__/cache.mjs

@@ -1,7 +0,0 @@
-import { vi } from 'vitest';
-export const getCache = vi
-    .fn()
-    .mockReturnValue({ cache: undefined, systemCache: undefined, lockCache: undefined });
-export const flushCaches = vi.fn();
-export const clearSystemCache = vi.fn();
-export const setSystemCache = vi.fn();