@directus/api 24.0.1 → 25.0.0

package/dist/middleware/respond.js

@@ -1,6 +1,7 @@
 import { useEnv } from '@directus/env';
 import { parse as parseBytesConfiguration } from 'bytes';
 import { getCache, setCacheValue } from '../cache.js';
+import getDatabase from '../database/index.js';
 import { useLogger } from '../logger/index.js';
 import { ExportService } from '../services/import-export.js';
 import asyncHandler from '../utils/async-handler.js';
@@ -9,6 +10,7 @@ import { getCacheKey } from '../utils/get-cache-key.js';
 import { getDateFormatted } from '../utils/get-date-formatted.js';
 import { getMilliseconds } from '../utils/get-milliseconds.js';
 import { stringByteSize } from '../utils/get-string-byte-size.js';
+import { permissionsCachable } from '../utils/permissions-cachable.js';
 export const respond = asyncHandler(async (req, res) => {
     const env = useEnv();
     const logger = useLogger();
@@ -26,7 +28,11 @@ export const respond = asyncHandler(async (req, res) => {
         cache &&
         !req.sanitizedQuery.export &&
         res.locals['cache'] !== false &&
-        exceedsMaxSize === false) {
+        exceedsMaxSize === false &&
+        (await permissionsCachable(req.collection, {
+            knex: getDatabase(),
+            schema: req.schema,
+        }, req.accountability))) {
         const key = await getCacheKey(req);
         try {
             await setCacheValue(cache, key, res.locals['payload'], getMilliseconds(env['CACHE_TTL']));

package/dist/operations/condition/index.js

@@ -1,11 +1,16 @@
-import { validatePayload } from '@directus/utils';
 import { defineOperationApi } from '@directus/extensions';
+import { validatePayload } from '@directus/utils';
+import { FailedValidationError, joiValidationErrorItemToErrorExtensions } from '@directus/validation';
 export default defineOperationApi({
     id: 'condition',
     handler: ({ filter }, { data }) => {
         const errors = validatePayload(filter, data, { requireAll: true });
         if (errors.length > 0) {
-            throw errors;
+            // sanitize and format errors
+            const validationErrors = errors
+                .map((error) => error.details.map((details) => new FailedValidationError(joiValidationErrorItemToErrorExtensions(details))))
+                .flat();
+            throw validationErrors;
         }
         else {
             return null;

package/dist/schedules/metrics.d.ts

@@ -0,0 +1,7 @@
+export declare function handleMetricsJob(): Promise<void>;
+/**
+ * Schedule the metric generation
+ *
+ * @returns Whether or not metrics has been initialized
+ */
+export default function schedule(): Promise<boolean>;

package/dist/schedules/metrics.js

@@ -0,0 +1,44 @@
+import { useEnv } from '@directus/env';
+import { toBoolean } from '@directus/utils';
+import { scheduleJob } from 'node-schedule';
+import { useLogger } from '../logger/index.js';
+import { useMetrics } from '../metrics/index.js';
+import { validateCron } from '../utils/schedule.js';
+const METRICS_LOCK_TIMEOUT = 10 * 60 * 1000; // 10 mins
+let lockedAt = 0;
+const logger = useLogger();
+const metrics = useMetrics();
+export async function handleMetricsJob() {
+    const now = Date.now();
+    if (lockedAt !== 0 && lockedAt > now - METRICS_LOCK_TIMEOUT) {
+        // ensure only generating metrics once per node
+        return;
+    }
+    lockedAt = Date.now();
+    try {
+        await metrics?.generate();
+    }
+    catch (err) {
+        logger.warn(`An error was thrown while attempting metric generation`);
+        logger.warn(err);
+    }
+    finally {
+        lockedAt = 0;
+    }
+}
+/**
+ * Schedule the metric generation
+ *
+ * @returns Whether or not metrics has been initialized
+ */
+export default async function schedule() {
+    const env = useEnv();
+    if (!toBoolean(env['METRICS_ENABLED'])) {
+        return false;
+    }
+    if (!validateCron(String(env['METRICS_SCHEDULE']))) {
+        return false;
+    }
+    scheduleJob('metrics', String(env['METRICS_SCHEDULE']), handleMetricsJob);
+    return true;
+}

package/dist/services/assets.d.ts

@@ -10,9 +10,14 @@ export declare class AssetsService {
     schema: SchemaOverview;
     filesService: FilesService;
     constructor(options: AbstractServiceOptions);
-    getAsset(id: string, transformation?: TransformationSet, range?: Range): Promise<{
+    getAsset(id: string, transformation?: TransformationSet, range?: Range, deferStream?: false): Promise<{
         stream: Readable;
         file: any;
         stat: Stat;
     }>;
+    getAsset(id: string, transformation?: TransformationSet, range?: Range, deferStream?: true): Promise<{
+        stream: () => Promise<Readable>;
+        file: any;
+        stat: Stat;
+    }>;
 }

package/dist/services/assets.js

@@ -28,7 +28,7 @@ export class AssetsService {
         this.schema = options.schema;
         this.filesService = new FilesService({ ...options, accountability: null });
     }
-    async getAsset(id, transformation, range) {
+    async getAsset(id, transformation, range, deferStream = false) {
         const storage = await getStorage();
         const publicSettings = await this.knex
             .select('project_logo', 'public_background', 'public_foreground', 'public_favicon')
@@ -99,8 +99,9 @@ export class AssetsService {
                 file.type = contentType(assetFilename) || null;
             }
             if (exists) {
+                const assetStream = () => storage.location(file.storage).read(assetFilename, { range });
                 return {
-                    stream: await storage.location(file.storage).read(assetFilename, { range }),
+                    stream: deferStream ? assetStream : await assetStream(),
                     file,
                     stat: await storage.location(file.storage).stat(assetFilename),
                 };
@@ -123,7 +124,6 @@ export class AssetsService {
                     reason: 'Server too busy',
                 });
             }
-            const readStream = await storage.location(file.storage).read(file.filename_disk, { range, version });
             const transformer = getSharpInstance();
             transformer.timeout({
                 seconds: clamp(Math.round(getMilliseconds(env['ASSETS_TRANSFORM_TIMEOUT'], 0) / 1000), 1, 3600),
@@ -131,6 +131,7 @@ export class AssetsService {
             if (transforms.find((transform) => transform[0] === 'rotate') === undefined)
                 transformer.rotate();
             transforms.forEach(([method, ...args]) => transformer[method].apply(transformer, args));
+            const readStream = await storage.location(file.storage).read(file.filename_disk, { range, version });
             readStream.on('error', (e) => {
                 logger.error(e, `Couldn't transform file ${file.id}`);
                 readStream.unpipe(transformer);
@@ -152,16 +153,17 @@ export class AssetsService {
                     throw error;
                 }
             }
+            const assetStream = () => storage.location(file.storage).read(assetFilename, { range, version });
             return {
-                stream: await storage.location(file.storage).read(assetFilename, { range, version }),
+                stream: deferStream ? assetStream : await assetStream(),
                 stat: await storage.location(file.storage).stat(assetFilename),
                 file,
             };
         }
         else {
-            const readStream = await storage.location(file.storage).read(file.filename_disk, { range, version });
+            const assetStream = () => storage.location(file.storage).read(file.filename_disk, { range, version });
             const stat = await storage.location(file.storage).stat(file.filename_disk);
-            return { stream: readStream, file, stat };
+            return { stream: deferStream ? assetStream : await assetStream(), file, stat };
         }
     }
 }

package/dist/services/fields.js

@@ -58,7 +58,7 @@ export class FieldsService {
         if (!columnInfo) {
             columnInfo = await this.schemaInspector.columnInfo();
             if (schemaCacheIsEnabled) {
-                setCacheValue(this.schemaCache, 'columnInfo', columnInfo);
+                await setCacheValue(this.schemaCache, 'columnInfo', columnInfo);
             }
         }
         if (collection) {

package/dist/services/graphql/errors/format.d.ts

@@ -0,0 +1,6 @@
+import { type DirectusError } from '@directus/errors';
+import { GraphQLError } from 'graphql';
+/**
+ * Convert Directus-Exception into a GraphQL format, so it can be returned by GraphQL properly.
+ */
+export declare function formatError(error: DirectusError | DirectusError[]): GraphQLError;

package/dist/services/graphql/errors/format.js

@@ -0,0 +1,14 @@
+import {} from '@directus/errors';
+import { GraphQLError } from 'graphql';
+import { set } from 'lodash-es';
+/**
+ * Convert Directus-Exception into a GraphQL format, so it can be returned by GraphQL properly.
+ */
+export function formatError(error) {
+    if (Array.isArray(error)) {
+        set(error[0], 'extensions.code', error[0].code);
+        return new GraphQLError(error[0].message, undefined, undefined, undefined, undefined, error[0]);
+    }
+    set(error, 'extensions.code', error.code);
+    return new GraphQLError(error.message, undefined, undefined, undefined, undefined, error);
+}

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

@@ -1,17 +1,15 @@
-import { type DirectusError } from '@directus/errors';
-import type { Accountability, Filter, Item, Query, SchemaOverview } from '@directus/types';
-import type { ArgumentNode, FormattedExecutionResult, FragmentDefinitionNode, GraphQLResolveInfo, SelectionNode } from 'graphql';
-import { GraphQLError, GraphQLSchema } from 'graphql';
-import { ObjectTypeComposer, SchemaComposer } from 'graphql-compose';
+import type { Accountability, Item, Query, SchemaOverview } from '@directus/types';
+import type { FormattedExecutionResult, GraphQLSchema } from 'graphql';
 import type { Knex } from 'knex';
 import type { AbstractServiceOptions, GraphQLParams } from '../../types/index.js';
+export type GQLScope = 'items' | 'system';
 export declare class GraphQLService {
     accountability: Accountability | null;
     knex: Knex;
     schema: SchemaOverview;
-    scope: 'items' | 'system';
+    scope: GQLScope;
     constructor(options: AbstractServiceOptions & {
-        scope: 'items' | 'system';
+        scope: GQLScope;
     });
     /**
      * Execute a GraphQL structure
@@ -23,12 +21,6 @@ export declare class GraphQLService {
     getSchema(): Promise<GraphQLSchema>;
     getSchema(type: 'schema'): Promise<GraphQLSchema>;
     getSchema(type: 'sdl'): Promise<GraphQLSchema | string>;
-    /**
-     * Generic resolver that's used for every "regular" items/system query. Converts the incoming GraphQL AST / fragments into
-     * Directus' query structure which is then executed by the services.
-     */
-    resolveQuery(info: GraphQLResolveInfo): Promise<Partial<Item> | null>;
-    resolveMutation(args: Record<string, any>, info: GraphQLResolveInfo): Promise<Partial<Item> | boolean | undefined>;
     /**
      * Execute the read action on the correct service. Checks for singleton as well.
      */
@@ -37,44 +29,4 @@ export declare class GraphQLService {
      * Upsert and read singleton item
      */
     upsertSingleton(collection: string, body: Record<string, any> | Record<string, any>[], query: Query): Promise<Partial<Item> | boolean>;
-    /**
-     * GraphQL's regular resolver `args` variable only contains the "top-level" arguments. Seeing that we convert the
-     * whole nested tree into one big query using Directus' own query resolver, we want to have a nested structure of
-     * arguments for the whole resolving tree, which can later be transformed into Directus' AST using `deep`.
-     * In order to do that, we'll parse over all ArgumentNodes and ObjectFieldNodes to manually recreate an object structure
-     * of arguments
-     */
-    parseArgs(args: readonly ArgumentNode[], variableValues: GraphQLResolveInfo['variableValues']): Record<string, any>;
-    /**
-     * Get a Directus Query object from the parsed arguments (rawQuery) and GraphQL AST selectionSet. Converts SelectionSet into
-     * Directus' `fields` query for use in the resolver. Also applies variables where appropriate.
-     */
-    getQuery(rawQuery: Query, selections: readonly SelectionNode[], variableValues: GraphQLResolveInfo['variableValues']): Query;
-    /**
-     * Resolve the aggregation query based on the requested aggregated fields
-     */
-    getAggregateQuery(rawQuery: Query, selections: readonly SelectionNode[]): Query;
-    /**
-     * Replace functions from GraphQL format to Directus-Filter format
-     */
-    replaceFuncs(filter: Filter): Filter;
-    /**
-     * Convert Directus-Exception into a GraphQL format, so it can be returned by GraphQL properly.
-     */
-    formatError(error: DirectusError | DirectusError[]): GraphQLError;
-    /**
-     * Replace all fragments in a selectionset for the actual selection set as defined in the fragment
-     * Effectively merges the selections with the fragments used in those selections
-     */
-    replaceFragmentsInSelections(selections: readonly SelectionNode[] | undefined, fragments: Record<string, FragmentDefinitionNode>): readonly SelectionNode[] | null;
-    injectSystemResolvers(schemaComposer: SchemaComposer<GraphQLParams['contextValue']>, { CreateCollectionTypes, ReadCollectionTypes, UpdateCollectionTypes, }: {
-        CreateCollectionTypes: Record<string, ObjectTypeComposer<any, any>>;
-        ReadCollectionTypes: Record<string, ObjectTypeComposer<any, any>>;
-        UpdateCollectionTypes: Record<string, ObjectTypeComposer<any, any>>;
-    }, schema: {
-        create: SchemaOverview;
-        read: SchemaOverview;
-        update: SchemaOverview;
-        delete: SchemaOverview;
-    }): SchemaComposer<any>;
 }