@directus/api 14.1.1 → 15.0.0

package/dist/redis/use-redis.d.ts

@@ -0,0 +1,16 @@
+import { Redis } from 'ioredis';
+/**
+ * Memoization cache for useRedis
+ *
+ * @see {@link useRedis}
+ */
+export declare const _cache: {
+    redis: Redis | undefined;
+};
+/**
+ * Access the globally shared Redis instance
+ * Creates new Redis instance on first invocation
+ *
+ * @returns Globally shared Redis instance
+ */
+export declare const useRedis: () => Redis;

package/dist/redis/use-redis.js

@@ -0,0 +1,22 @@
+import { Redis } from 'ioredis';
+import { createRedis } from './create-redis.js';
+/**
+ * Memoization cache for useRedis
+ *
+ * @see {@link useRedis}
+ */
+export const _cache = {
+    redis: undefined,
+};
+/**
+ * Access the globally shared Redis instance
+ * Creates new Redis instance on first invocation
+ *
+ * @returns Globally shared Redis instance
+ */
+export const useRedis = () => {
+    if (_cache.redis)
+        return _cache.redis;
+    _cache.redis = createRedis();
+    return _cache.redis;
+};

package/dist/server.d.ts

@@ -1,4 +1,6 @@
 /// <reference types="node" resolution-mode="require"/>
+/// <reference types="node/http.js" />
+/// <reference types="pino-http" />
 import * as http from 'http';
 export declare let SERVER_ONLINE: boolean;
 export declare function createServer(): Promise<http.Server>;

package/dist/services/extensions.js

@@ -46,7 +46,7 @@ export class ExtensionsService {
             throw new ForbiddenError();
         }
         const key = this.getKey(bundle, name);
-        const schema = this.extensionsManager.getExtensions().find((extension) => extension.name === bundle ?? name);
+        const schema = this.extensionsManager.getExtensions().find((extension) => extension.name === (bundle ?? name));
         const meta = await this.extensionsItemService.readOne(key);
         const stitched = this.stitch(schema ? [schema] : [], [meta])[0];
         if (stitched)

package/dist/services/graphql/index.js

@@ -126,7 +126,7 @@ export class GraphQLService {
                 delete: { value: 'delete' },
             },
         });
-        const { ReadCollectionTypes } = getReadableTypes();
+        const { ReadCollectionTypes, VersionCollectionTypes } = getReadableTypes();
         const { CreateCollectionTypes, UpdateCollectionTypes, DeleteCollectionTypes } = getWritableTypes();
         const scopeFilter = (collection) => {
             if (this.scope === 'items' && collection.collection.startsWith('directus_') === true)
@@ -158,6 +158,9 @@ export class GraphQLService {
                     acc[`${collectionName}_by_id`] = ReadCollectionTypes[collection.collection].getResolver(`${collection.collection}_by_id`);
                     acc[`${collectionName}_aggregated`] = ReadCollectionTypes[collection.collection].getResolver(`${collection.collection}_aggregated`);
                 }
+                if (this.scope === 'items') {
+                    acc[`${collectionName}_by_version`] = VersionCollectionTypes[collection.collection].getResolver(`${collection.collection}_by_version`);
+                }
                 return acc;
             }, {}));
         }
@@ -221,6 +224,7 @@ export class GraphQLService {
          */
         function getTypes(action) {
             const CollectionTypes = {};
+            const VersionTypes = {};
             const CountFunctions = schemaComposer.createObjectTC({
                 name: 'count_functions',
                 fields: {
@@ -289,13 +293,19 @@ export class GraphQLService {
                             type = new GraphQLNonNull(type);
                         }
                         if (collection.primary === field.field) {
-                            if (!field.defaultValue && !field.special.includes('uuid') && action === 'create') {
+                            // permissions IDs need to be nullable https://github.com/directus/directus/issues/20509
+                            if (collection.collection === 'directus_permissions') {
+                                type = GraphQLID;
+                            }
+                            else if (!field.defaultValue && !field.special.includes('uuid') && action === 'create') {
                                 type = new GraphQLNonNull(GraphQLID);
                             }
-                            else if (['create', 'update'].includes(action))
+                            else if (['create', 'update'].includes(action)) {
                                 type = GraphQLID;
-                            else
+                            }
+                            else {
                                 type = new GraphQLNonNull(GraphQLID);
+                            }
                         }
                         acc[field.field] = {
                             type,
@@ -345,6 +355,9 @@ export class GraphQLService {
                         return acc;
                     }, {}),
                 });
+                if (self.scope === 'items') {
+                    VersionTypes[collection.collection] = CollectionTypes[collection.collection].clone(`version_${collection.collection}`);
+                }
             }
             for (const relation of schema[action].relations) {
                 if (relation.related_collection) {
@@ -367,6 +380,16 @@ export class GraphQLService {
                                 },
                             },
                         });
+                        if (self.scope === 'items') {
+                            VersionTypes[relation.related_collection]?.addFields({
+                                [relation.meta.one_field]: {
+                                    type: GraphQLJSON,
+                                    resolve: (obj, _, __, info) => {
+                                        return obj[info?.path?.key ?? relation.meta.one_field];
+                                    },
+                                },
+                            });
+                        }
                     }
                 }
                 else if (relation.meta?.one_allowed_collections && action === 'read') {
@@ -399,13 +422,13 @@ export class GraphQLService {
                     });
                 }
             }
-            return { CollectionTypes };
+            return { CollectionTypes, VersionTypes };
         }
         /**
          * Create readable types and attach resolvers for each. Also prepares full filter argument structures
          */
         function getReadableTypes() {
-            const { CollectionTypes: ReadCollectionTypes } = getTypes('read');
+            const { CollectionTypes: ReadCollectionTypes, VersionTypes: VersionCollectionTypes } = getTypes('read');
             const ReadableCollectionFilterTypes = {};
             const AggregatedFunctions = {};
             const AggregatedFields = {};
@@ -843,13 +866,6 @@ export class GraphQLService {
                         },
                     };
                 }
-                else {
-                    resolver.args = {
-                        version: {
-                            type: GraphQLString,
-                        },
-                    };
-                }
                 ReadCollectionTypes[collection.collection].addResolver(resolver);
                 ReadCollectionTypes[collection.collection].addResolver({
                     name: `${collection.collection}_aggregated`,
@@ -885,7 +901,6 @@ export class GraphQLService {
                         type: ReadCollectionTypes[collection.collection],
                         args: {
                             id: new GraphQLNonNull(GraphQLID),
-                            version: GraphQLString,
                         },
                         resolve: async ({ info, context }) => {
                             const result = await self.resolveQuery(info);
@@ -894,6 +909,23 @@ export class GraphQLService {
                         },
                     });
                 }
+                if (self.scope === 'items') {
+                    VersionCollectionTypes[collection.collection].addResolver({
+                        name: `${collection.collection}_by_version`,
+                        type: VersionCollectionTypes[collection.collection],
+                        args: collection.singleton
+                            ? { version: new GraphQLNonNull(GraphQLString) }
+                            : {
+                                version: new GraphQLNonNull(GraphQLString),
+                                id: new GraphQLNonNull(GraphQLID),
+                            },
+                        resolve: async ({ info, context }) => {
+                            const result = await self.resolveQuery(info);
+                            context['data'] = result;
+                            return result;
+                        },
+                    });
+                }
                 const eventName = `${collection.collection}_mutated`;
                 if (collection.collection in ReadCollectionTypes) {
                     const subscriptionType = schemaComposer.createObjectTC({
@@ -973,7 +1005,7 @@ export class GraphQLService {
                     }
                 }
             }
-            return { ReadCollectionTypes, ReadableCollectionFilterTypes };
+            return { ReadCollectionTypes, VersionCollectionTypes, ReadableCollectionFilterTypes };
         }
         function getWritableTypes() {
             const { CollectionTypes: CreateCollectionTypes } = getTypes('create');
@@ -1135,6 +1167,9 @@ export class GraphQLService {
             if (collection.endsWith('_by_id') && collection in this.schema.collections === false) {
                 collection = collection.slice(0, -6);
             }
+            if (collection.endsWith('_by_version') && collection in this.schema.collections === false) {
+                collection = collection.slice(0, -11);
+            }
         }
         if (args['id']) {
             query.filter = {

package/dist/services/payload.js

@@ -1,13 +1,13 @@
+import { ForbiddenError, InvalidPayloadError } from '@directus/errors';
 import { parseJSON, toArray } from '@directus/utils';
 import { format, isValid, parseISO } from 'date-fns';
-import flat from 'flat';
+import { unflatten } from 'flat';
 import Joi from 'joi';
 import { clone, cloneDeep, isNil, isObject, isPlainObject, omit, pick } from 'lodash-es';
 import { v4 as uuid } from 'uuid';
 import { parse as wktToGeoJSON } from 'wellknown';
 import { getHelpers } from '../database/helpers/index.js';
 import getDatabase from '../database/index.js';
-import { ForbiddenError, InvalidPayloadError } from '@directus/errors';
 import { generateHash } from '../utils/generate-hash.js';
 import { ItemsService } from './items.js';
 /**
@@ -164,7 +164,7 @@ export class PayloadService {
         const aggregateKeys = Object.keys(payload[0]).filter((key) => key.includes('->'));
         if (aggregateKeys.length) {
             for (const item of payload) {
-                Object.assign(item, flat.unflatten(pick(item, aggregateKeys), { delimiter: '->' }));
+                Object.assign(item, unflatten(pick(item, aggregateKeys), { delimiter: '->' }));
                 aggregateKeys.forEach((key) => delete item[key]);
             }
         }

package/dist/services/server.js

@@ -1,4 +1,5 @@
 import { toArray } from '@directus/utils';
+import { version } from 'directus/version';
 import { merge } from 'lodash-es';
 import { Readable } from 'node:stream';
 import { performance } from 'perf_hooks';
@@ -11,7 +12,6 @@ import { rateLimiterGlobal } from '../middleware/rate-limiter-global.js';
 import { rateLimiter } from '../middleware/rate-limiter-ip.js';
 import { SERVER_ONLINE } from '../server.js';
 import { getStorage } from '../storage/index.js';
-import { version } from '../utils/package.js';
 import { toBoolean } from '../utils/to-boolean.js';
 import { SettingsService } from './settings.js';
 export class ServerService {
@@ -70,8 +70,6 @@ export class ServerService {
                 default: env['QUERY_LIMIT_DEFAULT'],
                 max: Number.isFinite(env['QUERY_LIMIT_MAX']) ? env['QUERY_LIMIT_MAX'] : -1,
             };
-        }
-        if (this.accountability?.user) {
             if (toBoolean(env['WEBSOCKETS_ENABLED'])) {
                 info['websocket'] = {};
                 info['websocket'].rest = toBoolean(env['WEBSOCKETS_REST_ENABLED'])
@@ -93,6 +91,7 @@ export class ServerService {
             else {
                 info['websocket'] = false;
             }
+            info['version'] = version;
         }
         return info;
     }

package/dist/services/specifications.js

@@ -1,13 +1,13 @@
 import formatTitle from '@directus/format-title';
 import { spec } from '@directus/specs';
+import { version } from 'directus/version';
 import { cloneDeep, mergeWith } from 'lodash-es';
 import { OAS_REQUIRED_SCHEMAS } from '../constants.js';
 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 { GraphQLService } from './graphql/index.js';
 import { reduceSchema } from '../utils/reduce-schema.js';
+import { GraphQLService } from './graphql/index.js';
 export class SpecificationService {
     accountability;
     knex;
@@ -19,7 +19,7 @@ export class SpecificationService {
         this.knex = knex || getDatabase();
         this.schema = schema;
         this.oas = new OASSpecsService({ knex, schema, accountability });
-        this.graphql = new GraphQLSpecsService({ knex, schema });
+        this.graphql = new GraphQLSpecsService({ knex, schema, accountability });
     }
 }
 class OASSpecsService {

package/dist/services/users.js

@@ -116,7 +116,7 @@ export class UsersService extends ItemsService {
      */
     async getUserByEmail(email) {
         return await this.knex
-            .select('id', 'role', 'status', 'password')
+            .select('id', 'role', 'status', 'password', 'email')
             .from('directus_users')
             .whereRaw(`LOWER(??) = ?`, ['email', email.toLowerCase()])
             .first();
@@ -325,13 +325,13 @@ export class UsersService extends ItemsService {
             if (isEmpty(user) || user.status === 'invited') {
                 const subjectLine = subject ?? "You've been invited";
                 await mailService.send({
-                    to: email,
+                    to: user.email,
                     subject: subjectLine,
                     template: {
                         name: 'user-invitation',
                         data: {
                             url: this.inviteUrl(email, url),
-                            email,
+                            email: user.email,
                         },
                     },
                 });
@@ -369,20 +369,20 @@ export class UsersService extends ItemsService {
             knex: this.knex,
             accountability: this.accountability,
         });
-        const payload = { email, scope: 'password-reset', hash: getSimpleHash('' + user.password) };
+        const payload = { email: user.email, scope: 'password-reset', hash: getSimpleHash('' + user.password) };
         const token = jwt.sign(payload, env['SECRET'], { expiresIn: '1d', issuer: 'directus' });
         const acceptURL = url
             ? new Url(url).setQuery('token', token).toString()
             : new Url(env['PUBLIC_URL']).addPath('admin', 'reset-password').setQuery('token', token).toString();
         const subjectLine = subject ? subject : 'Password Reset Request';
         await mailService.send({
-            to: email,
+            to: user.email,
             subject: subjectLine,
             template: {
                 name: 'password-reset',
                 data: {
                     url: acceptURL,
-                    email,
+                    email: user.email,
                 },
             },
         });

package/dist/telemetry/index.d.ts

@@ -0,0 +1,4 @@
+export * from './lib/get-report.js';
+export * from './lib/init-telemetry.js';
+export * from './lib/send-report.js';
+export * from './lib/track.js';

package/dist/telemetry/index.js

@@ -0,0 +1,4 @@
+export * from './lib/get-report.js';
+export * from './lib/init-telemetry.js';
+export * from './lib/send-report.js';
+export * from './lib/track.js';

package/dist/telemetry/lib/get-report.d.ts

@@ -0,0 +1,5 @@
+import type { TelemetryReport } from '../types/report.js';
+/**
+ * Create a telemetry report about the anonymous usage of the current installation
+ */
+export declare const getReport: () => Promise<TelemetryReport>;

package/dist/telemetry/lib/get-report.js

@@ -0,0 +1,42 @@
+import { version } from 'directus/version';
+import { getDatabase, getDatabaseClient } from '../../database/index.js';
+import { useEnv } from '../../env.js';
+import { getItemCount } from '../utils/get-item-count.js';
+import { getUserCount } from '../utils/get-user-count.js';
+import { getUserItemCount } from '../utils/get-user-item-count.js';
+const basicCountCollections = [
+    'directus_dashboards',
+    'directus_extensions',
+    'directus_files',
+    'directus_flows',
+    'directus_roles',
+    'directus_shares',
+];
+/**
+ * Create a telemetry report about the anonymous usage of the current installation
+ */
+export const getReport = async () => {
+    const db = getDatabase();
+    const env = useEnv();
+    const [basicCounts, userCounts, userItemCount] = await Promise.all([
+        getItemCount(db, basicCountCollections),
+        getUserCount(db),
+        getUserItemCount(db),
+    ]);
+    return {
+        url: env['PUBLIC_URL'],
+        version: version,
+        database: getDatabaseClient(),
+        dashboards: basicCounts.directus_dashboards,
+        extensions: basicCounts.directus_extensions,
+        files: basicCounts.directus_files,
+        flows: basicCounts.directus_flows,
+        roles: basicCounts.directus_roles,
+        shares: basicCounts.directus_shares,
+        admin_users: userCounts.admin,
+        app_users: userCounts.app,
+        api_users: userCounts.api,
+        collections: userItemCount.collections,
+        items: userItemCount.items,
+    };
+};

package/dist/telemetry/lib/init-telemetry.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Exported to be able to test the anonymous callback function
+ */
+export declare const jobCallback: () => void;
+/**
+ * Initialize the telemetry tracking. Will generate a report on start, and set a schedule to report
+ * every 6 hours
+ *
+ * @returns Whether or not telemetry has been initialized
+ */
+export declare const initTelemetry: () => Promise<boolean>;

package/dist/telemetry/lib/init-telemetry.js

@@ -0,0 +1,30 @@
+import { getCache } from '../../cache.js';
+import { useEnv } from '../../env.js';
+import { scheduleSynchronizedJob } from '../../utils/schedule.js';
+import { toBoolean } from '../../utils/to-boolean.js';
+import { track } from './track.js';
+/**
+ * Exported to be able to test the anonymous callback function
+ */
+export const jobCallback = () => {
+    track();
+};
+/**
+ * Initialize the telemetry tracking. Will generate a report on start, and set a schedule to report
+ * every 6 hours
+ *
+ * @returns Whether or not telemetry has been initialized
+ */
+export const initTelemetry = async () => {
+    const env = useEnv();
+    if (toBoolean(env['TELEMETRY']) === false)
+        return false;
+    scheduleSynchronizedJob('telemetry', '0 */6 * * *', jobCallback);
+    const { lockCache } = getCache();
+    if (!(await lockCache.get('telemetry-lock'))) {
+        await lockCache.set('telemetry-lock', true, 30000);
+        track({ wait: false });
+        // Don't flush the lock. We want to debounce these calls across containers on startup
+    }
+    return true;
+};

package/dist/telemetry/lib/send-report.d.ts

@@ -0,0 +1,5 @@
+import type { TelemetryReport } from '../types/report.js';
+/**
+ * Post an anonymous usage report to the centralized intake server
+ */
+export declare const sendReport: (report: TelemetryReport) => Promise<void>;

package/dist/telemetry/lib/send-report.js

@@ -0,0 +1,23 @@
+import { URL } from 'node:url';
+import { useEnv } from '../../env.js';
+/**
+ * Post an anonymous usage report to the centralized intake server
+ */
+export const sendReport = async (report) => {
+    const env = useEnv();
+    const url = new URL('/v1/metrics', env['TELEMETRY_URL']);
+    const headers = {
+        'Content-Type': 'application/json',
+    };
+    if (env['TELEMETRY_AUTHORIZATION']) {
+        headers['Authorization'] = env['TELEMETRY_AUTHORIZATION'];
+    }
+    const res = await fetch(url, {
+        method: 'POST',
+        body: JSON.stringify(report),
+        headers,
+    });
+    if (!res.ok) {
+        throw new Error(`[${res.status}] ${await res.text()}`);
+    }
+};

package/dist/telemetry/lib/track.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Generate and send a report. Will log on error, but not throw. No need to be awaited
+ *
+ * @param opts Options for the tracking
+ * @param opts.wait Whether or not to wait a random amount of time between 0 and 30 minutes
+ * @returns whether or not the tracking was successful
+ */
+export declare const track: (opts?: {
+    wait: boolean;
+}) => Promise<boolean>;

package/dist/telemetry/lib/track.js

@@ -0,0 +1,31 @@
+import { setTimeout } from 'timers/promises';
+import { useEnv } from '../../env.js';
+import { useLogger } from '../../logger.js';
+import { getRandomWaitTime } from '../utils/get-random-wait-time.js';
+import { getReport } from './get-report.js';
+import { sendReport } from './send-report.js';
+/**
+ * Generate and send a report. Will log on error, but not throw. No need to be awaited
+ *
+ * @param opts Options for the tracking
+ * @param opts.wait Whether or not to wait a random amount of time between 0 and 30 minutes
+ * @returns whether or not the tracking was successful
+ */
+export const track = async (opts = { wait: true }) => {
+    const env = useEnv();
+    const logger = useLogger();
+    if (opts.wait) {
+        await setTimeout(getRandomWaitTime());
+    }
+    try {
+        const report = await getReport();
+        await sendReport(report);
+        return true;
+    }
+    catch (err) {
+        if (env['NODE_ENV'] === 'development') {
+            logger.error(err);
+        }
+        return false;
+    }
+};

package/dist/telemetry/types/report.d.ts

@@ -0,0 +1,58 @@
+export interface TelemetryReport {
+    /**
+     * The project's web-facing public URL
+     */
+    url: string;
+    /**
+     * Current Directus version in use
+     */
+    version: string;
+    /**
+     * Database client in use
+     */
+    database: string;
+    /**
+     * Number of users in the system that have admin access to the system
+     */
+    admin_users: number;
+    /**
+     * Number of users that can access the app, but don't have admin access
+     */
+    app_users: number;
+    /**
+     * Number of users that can only access the API
+     */
+    api_users: number;
+    /**
+     * Number of unique roles in the system
+     */
+    roles: number;
+    /**
+     * Number of unique flows in the system
+     */
+    flows: number;
+    /**
+     * Number of unique dashboards in the system
+     */
+    dashboards: number;
+    /**
+     * Number of installed extensions in the system. Does not differentiate between enabled/disabled
+     */
+    extensions: number;
+    /**
+     * Number of Directus-managed collections
+     */
+    collections: number;
+    /**
+     * Total number of items in the non-system tables
+     */
+    items: number;
+    /**
+     * Number of files in the system
+     */
+    files: number;
+    /**
+     * Number of shares in the system
+     */
+    shares: number;
+}

package/dist/telemetry/types/report.js

@@ -0,0 +1 @@
+export {};

package/dist/telemetry/utils/get-item-count.d.ts

@@ -0,0 +1,26 @@
+import { type Knex } from 'knex';
+export interface CollectionCount {
+    collection: string;
+    count: number;
+}
+/**
+ * Get the item count of the given collection in the given database
+ * @param db Knex instance to count against
+ * @param collection Table to count rows in
+ * @returns Collection name and count
+ */
+export declare const countCollection: (db: Knex, collection: string) => Promise<CollectionCount>;
+/**
+ * Merge the given collection count in the object accumulator
+ * Intended for use with .reduce()
+ * @param acc Accumulator
+ * @param value Current collection count object in array
+ * @returns Updated accumulator
+ */
+export declare const mergeResults: (acc: Record<string, number>, value: CollectionCount) => Record<string, number>;
+/**
+ * Get an object of item counts for the given collections
+ * @param db Database instance to get counts in
+ * @param collections Array of table names to get count from
+ */
+export declare const getItemCount: <T extends readonly string[]>(db: Knex, collections: T) => Promise<Record<T[number], number>>;

package/dist/telemetry/utils/get-item-count.js

@@ -0,0 +1,36 @@
+import {} from 'knex';
+import pLimit from 'p-limit';
+/**
+ * Get the item count of the given collection in the given database
+ * @param db Knex instance to count against
+ * @param collection Table to count rows in
+ * @returns Collection name and count
+ */
+export const countCollection = async (db, collection) => {
+    const count = await db.count('*', { as: 'count' }).from(collection).first();
+    return { collection, count: Number(count?.['count'] ?? 0) };
+};
+/**
+ * Merge the given collection count in the object accumulator
+ * Intended for use with .reduce()
+ * @param acc Accumulator
+ * @param value Current collection count object in array
+ * @returns Updated accumulator
+ */
+export const mergeResults = (acc, value) => {
+    acc[value.collection] = value.count;
+    return acc;
+};
+/**
+ * Get an object of item counts for the given collections
+ * @param db Database instance to get counts in
+ * @param collections Array of table names to get count from
+ */
+export const getItemCount = async (db, collections) => {
+    // Counts can be a little heavy if the table is very large, so we'll only ever execute 3 of these
+    // queries simultaneously to not overload the database
+    const limit = pLimit(3);
+    const calls = collections.map((collection) => limit(countCollection, db, collection));
+    const results = await Promise.all(calls);
+    return results.reduce(mergeResults, {});
+};

package/dist/telemetry/utils/get-random-wait-time.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Returns randomized value between 0 and 1.8e+6 (30min in ms) intended to be used as the randomized wait for
+ * telemetry tracking
+ */
+export declare const getRandomWaitTime: () => number;