@directus/api 14.1.1 → 15.0.0

package/dist/telemetry/utils/get-random-wait-time.js

@@ -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 const getRandomWaitTime = () => Math.floor(Math.random() * 1.8e6);

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

@@ -0,0 +1,7 @@
+import { type Knex } from 'knex';
+export interface UserCount {
+    admin: number;
+    app: number;
+    api: number;
+}
+export declare const getUserCount: (db: Knex) => Promise<UserCount>;

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

@@ -0,0 +1,30 @@
+import {} from 'knex';
+import { toBoolean } from '../../utils/to-boolean.js';
+export const getUserCount = async (db) => {
+    const counts = {
+        admin: 0,
+        app: 0,
+        api: 0,
+    };
+    const result = (await db
+        .count('directus_users.id', { as: 'count' })
+        .select('directus_roles.admin_access', 'directus_roles.app_access')
+        .from('directus_users')
+        .leftJoin('directus_roles', 'directus_users.role', '=', 'directus_roles.id')
+        .groupBy('directus_roles.admin_access', 'directus_roles.app_access'));
+    for (const record of result) {
+        const adminAccess = toBoolean(record.admin_access);
+        const appAccess = toBoolean(record.app_access);
+        const count = Number(record.count);
+        if (adminAccess) {
+            counts.admin = count;
+        }
+        else if (appAccess) {
+            counts.app = count;
+        }
+        else {
+            counts.api = count;
+        }
+    }
+    return counts;
+};

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

@@ -0,0 +1,13 @@
+import { type Knex } from 'knex';
+export interface UserItemCount {
+    collections: number;
+    items: number;
+}
+/**
+ * Sum all passed values together. Meant to be used with .reduce()
+ */
+export declare const sum: (acc: number, val: number) => number;
+/**
+ * Count all the items in the non-system tables
+ */
+export declare const getUserItemCount: (db: Knex) => Promise<UserItemCount>;

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

@@ -0,0 +1,18 @@
+import {} from 'knex';
+import { getSchema } from '../../utils/get-schema.js';
+import { getItemCount } from './get-item-count.js';
+/**
+ * Sum all passed values together. Meant to be used with .reduce()
+ */
+export const sum = (acc, val) => (acc += val);
+/**
+ * Count all the items in the non-system tables
+ */
+export const getUserItemCount = async (db) => {
+    const schema = await getSchema({ database: db });
+    const userCollections = Object.keys(schema.collections).filter((collection) => collection.startsWith('directus_') === false);
+    const counts = await getItemCount(db, userCollections);
+    const collections = userCollections.length;
+    const items = Object.values(counts).reduce(sum, 0);
+    return { collections, items };
+};

package/dist/utils/apply-query.js

@@ -405,9 +405,12 @@ export function applyFilter(knex, schema, rootQuery, rootFilter, collection, ali
             if (column.includes('(') && column.includes(')')) {
                 const functionName = column.split('(')[0];
                 const type = getOutputTypeForFunction(functionName);
-                if (['bigInteger', 'integer', 'float', 'decimal'].includes(type)) {
+                if (['integer', 'float', 'decimal'].includes(type)) {
                     compareValue = Number(compareValue);
                 }
+                else if (type === 'bigInteger') {
+                    compareValue = BigInt(compareValue);
+                }
             }
             // Cast filter value (compareValue) based on type of field being filtered against
             const [collection, field] = key.split('.');
@@ -422,7 +425,7 @@ export function applyFilter(knex, schema, rootQuery, rootFilter, collection, ali
                         compareValue = helpers.date.parse(compareValue);
                     }
                 }
-                if (['bigInteger', 'integer', 'float', 'decimal'].includes(type)) {
+                if (['integer', 'float', 'decimal'].includes(type)) {
                     if (Array.isArray(compareValue)) {
                         compareValue = compareValue.map((val) => Number(val));
                     }
@@ -430,6 +433,14 @@ export function applyFilter(knex, schema, rootQuery, rootFilter, collection, ali
                         compareValue = Number(compareValue);
                     }
                 }
+                if (type === 'bigInteger') {
+                    if (Array.isArray(compareValue)) {
+                        compareValue = compareValue.map((val) => BigInt(val));
+                    }
+                    else {
+                        compareValue = BigInt(compareValue);
+                    }
+                }
             }
             if (operator === '_eq') {
                 dbQuery[logical].where(selectionRaw, '=', compareValue);

package/dist/utils/get-cache-key.js

@@ -1,7 +1,7 @@
 import hash from 'object-hash';
 import url from 'url';
 import { getGraphqlQueryAndVariables } from './get-graphql-query-and-variables.js';
-import { version } from './package.js';
+import { version } from 'directus/version';
 export function getCacheKey(req) {
     const path = url.parse(req.originalUrl).pathname;
     const isGraphQl = path?.startsWith('/graphql');

package/dist/utils/get-ip-from-req.d.ts

@@ -1,2 +1,2 @@
 import type { Request } from 'express';
-export declare function getIPFromReq(req: Request): string;
+export declare function getIPFromReq(req: Request): string | null;

package/dist/utils/get-ip-from-req.js

@@ -13,5 +13,5 @@ export function getIPFromReq(req) {
         }
     }
     // IP addresses starting with ::ffff: are IPv4 addresses in IPv6 format. We can strip the prefix to get back to IPv4
-    return ip.startsWith('::ffff:') ? ip.substring(7) : ip;
+    return ip?.startsWith('::ffff:') ? ip.substring(7) : ip ?? null;
 }

package/dist/utils/get-permissions.js

@@ -86,9 +86,6 @@ function parsePermissions(permissions) {
         if (permission.permissions && typeof permission.permissions === 'string') {
             permission.permissions = parseJSON(permission.permissions);
         }
-        else if (permission.permissions === null) {
-            permission.permissions = {};
-        }
         if (permission.validation && typeof permission.validation === 'string') {
             permission.validation = parseJSON(permission.validation);
         }

package/dist/utils/get-snapshot-diff.js

@@ -55,7 +55,8 @@ export function getSnapshotDiff(current, after) {
             }),
             ...after.relations
                 .filter((afterRelation) => {
-                const currentRelation = current.relations.find((currentRelation) => currentRelation.collection === afterRelation.collection && afterRelation.field === currentRelation.field);
+                const currentRelation = current.relations.find((currentRelation) => currentRelation.collection === afterRelation.collection &&
+                    afterRelation.field === currentRelation.field);
                 return !!currentRelation === false;
             })
                 .map((afterRelation) => ({

package/dist/utils/get-snapshot.js

@@ -1,10 +1,10 @@
+import { version } from 'directus/version';
 import { fromPairs, isArray, isPlainObject, mapValues, omit, sortBy, toPairs } from 'lodash-es';
 import getDatabase, { getDatabaseClient } from '../database/index.js';
 import { CollectionsService } from '../services/collections.js';
 import { FieldsService } from '../services/fields.js';
 import { RelationsService } from '../services/relations.js';
 import { getSchema } from './get-schema.js';
-import { version } from './package.js';
 import { sanitizeCollection, sanitizeField, sanitizeRelation } from './sanitize-schema.js';
 export async function getSnapshot(options) {
     const database = options?.database ?? getDatabase();

package/dist/utils/get-versioned-hash.js

@@ -1,5 +1,5 @@
+import { version } from 'directus/version';
 import hash from 'object-hash';
-import { version } from './package.js';
 export function getVersionedHash(item) {
     return hash({ item, version });
 }

package/dist/utils/md.d.ts

@@ -1,4 +1,4 @@
 /**
  * Render and sanitize a markdown string
  */
-export declare function md(str: string): string;
+export declare function md(value: string): string;

package/dist/utils/md.js

@@ -3,6 +3,7 @@ import sanitizeHTML from 'sanitize-html';
 /**
  * Render and sanitize a markdown string
  */
-export function md(str) {
-    return sanitizeHTML(marked(str, { headerIds: false, mangle: false }));
+export function md(value) {
+    const markdown = marked.parse(value); /* Would only be a promise if used with async extensions */
+    return sanitizeHTML(markdown);
 }

package/dist/utils/merge-permissions.js

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

package/dist/utils/validate-query.js

@@ -96,6 +96,7 @@ function validateFilter(filter) {
             validateFilterPrimitive(nested, '_eq');
         }
         else {
+            // @ts-ignore TODO Check which case this is supposed to cover
             validateFilter(nested);
         }
     }

package/dist/utils/validate-snapshot.js

@@ -4,7 +4,7 @@ import { ALIAS_TYPES } from '../constants.js';
 import { getDatabaseClient } from '../database/index.js';
 import { InvalidPayloadError } from '@directus/errors';
 import { DatabaseClients } from '../types/index.js';
-import { version as currentDirectusVersion } from './package.js';
+import { version } from 'directus/version';
 const snapshotJoiSchema = Joi.object({
     version: Joi.number().valid(1).required(),
     directus: Joi.string().required(),
@@ -51,9 +51,9 @@ export function validateSnapshot(snapshot, force = false) {
     // Bypass checks when "force" option is enabled
     if (force)
         return;
-    if (snapshot.directus !== currentDirectusVersion) {
+    if (snapshot.directus !== version) {
         throw new InvalidPayloadError({
-            reason: `Provided snapshot's directus version ${snapshot.directus} does not match the current instance's version ${currentDirectusVersion}. You can bypass this check by passing the "force" query parameter`,
+            reason: `Provided snapshot's directus version ${snapshot.directus} does not match the current instance's version ${version}. You can bypass this check by passing the "force" query parameter`,
         });
     }
     if (!snapshot.vendor) {

package/dist/websocket/controllers/base.d.ts

@@ -2,6 +2,8 @@
 /// <reference types="node" resolution-mode="require"/>
 /// <reference types="node" resolution-mode="require"/>
 /// <reference types="node" resolution-mode="require"/>
+/// <reference types="node/http.js" />
+/// <reference types="pino-http" />
 import type { IncomingMessage, Server as httpServer } from 'http';
 import type { ParsedUrlQuery } from 'querystring';
 import type { RateLimiterAbstract } from 'rate-limiter-flexible';

package/dist/websocket/controllers/graphql.d.ts

@@ -1,4 +1,6 @@
 /// <reference types="node" resolution-mode="require"/>
+/// <reference types="node/http.js" />
+/// <reference types="pino-http" />
 import type { Server } from 'graphql-ws';
 import type { Server as httpServer } from 'http';
 import type { GraphQLSocket, UpgradeContext, WebSocketClient } from '../types.js';

package/dist/websocket/controllers/graphql.js

@@ -37,7 +37,7 @@ export class GraphQLSubscriptionController extends SocketController {
             send: (data) => new Promise((resolve, reject) => {
                 client.send(data, (err) => (err ? reject(err) : resolve()));
             }),
-            close: (code, reason) => client.close(code, reason),
+            close: (code, reason) => client.close(code, reason), // for standard closures
             onMessage: (cb) => {
                 client.on('parsed-message', async (message) => {
                     try {

package/dist/websocket/controllers/index.d.ts

@@ -1,4 +1,6 @@
 /// <reference types="node" resolution-mode="require"/>
+/// <reference types="node/http.js" />
+/// <reference types="pino-http" />
 import type { Server as httpServer } from 'http';
 import { GraphQLSubscriptionController } from './graphql.js';
 import { WebSocketController } from './rest.js';

package/dist/websocket/controllers/rest.d.ts

@@ -1,4 +1,6 @@
 /// <reference types="node" resolution-mode="require"/>
+/// <reference types="node/http.js" />
+/// <reference types="pino-http" />
 import type { Server as httpServer } from 'http';
 import { WebSocketMessage } from '../messages.js';
 import SocketController from './base.js';

package/dist/websocket/types.d.ts

@@ -1,6 +1,8 @@
 /// <reference types="node" resolution-mode="require"/>
 /// <reference types="node" resolution-mode="require"/>
 /// <reference types="node" resolution-mode="require"/>
+/// <reference types="node/http.js" />
+/// <reference types="pino-http" />
 import type { Accountability, Query } from '@directus/types';
 import type { IncomingMessage } from 'http';
 import type internal from 'stream';
@@ -12,7 +14,7 @@ export type AuthenticationState = {
 };
 export type WebSocketClient = WebSocket & AuthenticationState & {
     uid: string | number;
-    auth_timer: NodeJS.Timer | null;
+    auth_timer: NodeJS.Timeout | null;
 };
 export type UpgradeRequest = IncomingMessage & AuthenticationState;
 export type SubscriptionEvent = 'create' | 'update' | 'delete';