@directus/api 34.0.1 → 35.0.0

package/dist/utils/validate-query.js

@@ -1,213 +1,200 @@
-import { useEnv } from '@directus/env';
-import { InvalidQueryError } from '@directus/errors';
-import Joi from 'joi';
-import { isPlainObject, uniq } from 'lodash-es';
-import { stringify } from 'wellknown';
-import { calculateFieldDepth } from './calculate-field-depth.js';
-import { getFieldRelationalDepth } from './get-field-relational-depth.js';
+import { calculateFieldDepth } from "./calculate-field-depth.js";
+import { getFieldRelationalDepth } from "./get-field-relational-depth.js";
+import { useEnv } from "@directus/env";
+import { InvalidQueryError } from "@directus/errors";
+import { isPlainObject, uniq } from "lodash-es";
+import { stringify } from "wellknown";
+import Joi from "joi";
+
+//#region src/utils/validate-query.ts
 const env = useEnv();
 const querySchema = Joi.object({
-    fields: Joi.array().items(Joi.string()),
-    group: Joi.array().items(Joi.string()),
-    sort: Joi.array().items(Joi.string()),
-    filter: Joi.object({}).unknown(),
-    limit: 'QUERY_LIMIT_MAX' in env && env['QUERY_LIMIT_MAX'] !== -1
-        ? Joi.number()
-            .integer()
-            .min(-1)
-            .max(env['QUERY_LIMIT_MAX']) // min should be 0
-        : Joi.number().integer().min(-1),
-    offset: Joi.number().integer().min(0),
-    page: Joi.number().integer().min(0),
-    meta: Joi.array().items(Joi.string().valid('total_count', 'filter_count')),
-    search: Joi.string(),
-    export: Joi.string().valid('csv', 'csv_utf8', 'json', 'xml', 'yaml'),
-    version: Joi.string(),
-    versionRaw: Joi.boolean(),
-    aggregate: Joi.object(),
-    deep: Joi.object(),
-    alias: Joi.object(),
-    backlink: Joi.boolean(),
-}).id('query');
-export function validateQuery(query) {
-    const { error } = querySchema.validate(query);
-    if (query.filter && Object.keys(query.filter).length > 0) {
-        validateFilter(query.filter);
-    }
-    if (query.alias) {
-        validateAlias(query.alias);
-    }
-    validateRelationalDepth(query);
-    if (error) {
-        throw new InvalidQueryError({ reason: error.message });
-    }
-    return query;
+	fields: Joi.array().items(Joi.string()),
+	group: Joi.array().items(Joi.string()),
+	sort: Joi.array().items(Joi.string()),
+	filter: Joi.object({}).unknown(),
+	limit: "QUERY_LIMIT_MAX" in env && env["QUERY_LIMIT_MAX"] !== -1 ? Joi.number().integer().min(-1).max(env["QUERY_LIMIT_MAX"]) : Joi.number().integer().min(-1),
+	offset: Joi.number().integer().min(0),
+	page: Joi.number().integer().min(0),
+	meta: Joi.array().items(Joi.string().valid("total_count", "filter_count")),
+	search: Joi.string(),
+	export: Joi.string().valid("csv", "csv_utf8", "json", "xml", "yaml"),
+	version: Joi.string(),
+	versionRaw: Joi.boolean(),
+	aggregate: Joi.object(),
+	deep: Joi.object(),
+	alias: Joi.object(),
+	backlink: Joi.boolean()
+}).id("query");
+function validateQuery(query) {
+	const { error } = querySchema.validate(query);
+	if (query.filter && Object.keys(query.filter).length > 0) {
+		validateFilter(query.filter);
+	}
+	if (query.alias) {
+		validateAlias(query.alias);
+	}
+	validateRelationalDepth(query);
+	if (error) {
+		throw new InvalidQueryError({ reason: error.message });
+	}
+	return query;
 }
 function validateFilter(filter) {
-    for (const [key, nested] of Object.entries(filter)) {
-        if (key === '_and' || key === '_or') {
-            nested.forEach(validateFilter);
-        }
-        else if (key.startsWith('_')) {
-            const value = nested;
-            switch (key) {
-                case '_in':
-                case '_nin':
-                case '_between':
-                case '_nbetween':
-                    validateList(value, key);
-                    break;
-                case '_null':
-                case '_nnull':
-                case '_empty':
-                case '_nempty':
-                    validateBoolean(value, key);
-                    break;
-                case '_intersects':
-                case '_nintersects':
-                case '_intersects_bbox':
-                case '_nintersects_bbox':
-                    validateGeometry(value, key);
-                    break;
-                case '_none':
-                case '_some':
-                    validateFilter(nested);
-                    break;
-                case '_eq':
-                case '_neq':
-                case '_contains':
-                case '_ncontains':
-                case '_starts_with':
-                case '_nstarts_with':
-                case '_istarts_with':
-                case '_nistarts_with':
-                case '_ends_with':
-                case '_nends_with':
-                case '_iends_with':
-                case '_niends_with':
-                case '_gt':
-                case '_gte':
-                case '_lt':
-                case '_lte':
-                default:
-                    validateFilterPrimitive(value, key);
-                    break;
-            }
-        }
-        else if (isPlainObject(nested)) {
-            validateFilter(nested);
-        }
-        else if (Array.isArray(nested) === false) {
-            validateFilterPrimitive(nested, '_eq');
-        }
-        else {
-            // @ts-ignore TODO Check which case this is supposed to cover
-            validateFilter(nested);
-        }
-    }
+	for (const [key, nested] of Object.entries(filter)) {
+		if (key === "_and" || key === "_or") {
+			nested.forEach(validateFilter);
+		} else if (key.startsWith("_")) {
+			const value = nested;
+			switch (key) {
+				case "_in":
+				case "_nin":
+				case "_between":
+				case "_nbetween":
+					validateList(value, key);
+					break;
+				case "_null":
+				case "_nnull":
+				case "_empty":
+				case "_nempty":
+					validateBoolean(value, key);
+					break;
+				case "_intersects":
+				case "_nintersects":
+				case "_intersects_bbox":
+				case "_nintersects_bbox":
+					validateGeometry(value, key);
+					break;
+				case "_none":
+				case "_some":
+					validateFilter(nested);
+					break;
+				case "_eq":
+				case "_neq":
+				case "_contains":
+				case "_ncontains":
+				case "_starts_with":
+				case "_nstarts_with":
+				case "_istarts_with":
+				case "_nistarts_with":
+				case "_ends_with":
+				case "_nends_with":
+				case "_iends_with":
+				case "_niends_with":
+				case "_gt":
+				case "_gte":
+				case "_lt":
+				case "_lte":
+				default:
+					validateFilterPrimitive(value, key);
+					break;
+			}
+		} else if (isPlainObject(nested)) {
+			validateFilter(nested);
+		} else if (Array.isArray(nested) === false) {
+			validateFilterPrimitive(nested, "_eq");
+		} else {
+			validateFilter(nested);
+		}
+	}
 }
 function validateFilterPrimitive(value, key) {
-    if (value === null)
-        return true;
-    if ((typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean' || value instanceof Date) ===
-        false) {
-        throw new InvalidQueryError({ reason: `The filter value for "${key}" has to be a string, number, or boolean` });
-    }
-    if (typeof value === 'number' && (Number.isNaN(value) || value > Number.MAX_SAFE_INTEGER)) {
-        throw new InvalidQueryError({ reason: `The filter value for "${key}" is not a valid number` });
-    }
-    if (typeof value === 'string' && value.length === 0) {
-        throw new InvalidQueryError({
-            reason: `You can't filter for an empty string in "${key}". Use "_empty" or "_nempty" instead`,
-        });
-    }
-    return true;
+	if (value === null) return true;
+	if ((typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value instanceof Date) === false) {
+		throw new InvalidQueryError({ reason: `The filter value for "${key}" has to be a string, number, or boolean` });
+	}
+	if (typeof value === "number" && (Number.isNaN(value) || value > Number.MAX_SAFE_INTEGER)) {
+		throw new InvalidQueryError({ reason: `The filter value for "${key}" is not a valid number` });
+	}
+	if (typeof value === "string" && value.length === 0) {
+		throw new InvalidQueryError({ reason: `You can't filter for an empty string in "${key}". Use "_empty" or "_nempty" instead` });
+	}
+	return true;
 }
 function validateList(value, key) {
-    if (Array.isArray(value) === false || value.length === 0) {
-        throw new InvalidQueryError({ reason: `"${key}" has to be an array of values` });
-    }
-    return true;
+	if (Array.isArray(value) === false || value.length === 0) {
+		throw new InvalidQueryError({ reason: `"${key}" has to be an array of values` });
+	}
+	return true;
 }
-export function validateBoolean(value, key) {
-    if (value === null || value === '')
-        return true;
-    if (typeof value !== 'boolean') {
-        throw new InvalidQueryError({ reason: `"${key}" has to be a boolean` });
-    }
-    return true;
+function validateBoolean(value, key) {
+	if (value === null || value === "") return true;
+	if (typeof value !== "boolean") {
+		throw new InvalidQueryError({ reason: `"${key}" has to be a boolean` });
+	}
+	return true;
 }
-export function validateGeometry(value, key) {
-    if (value === null || value === '')
-        return true;
-    try {
-        stringify(value);
-    }
-    catch {
-        throw new InvalidQueryError({ reason: `"${key}" has to be a valid GeoJSON object` });
-    }
-    return true;
+function validateGeometry(value, key) {
+	if (value === null || value === "") return true;
+	try {
+		stringify(value);
+	} catch {
+		throw new InvalidQueryError({ reason: `"${key}" has to be a valid GeoJSON object` });
+	}
+	return true;
 }
 function validateAlias(alias) {
-    if (isPlainObject(alias) === false) {
-        throw new InvalidQueryError({ reason: `"alias" has to be an object` });
-    }
-    for (const [key, value] of Object.entries(alias)) {
-        if (typeof key !== 'string') {
-            throw new InvalidQueryError({ reason: `"alias" key has to be a string. "${typeof key}" given` });
-        }
-        if (typeof value !== 'string') {
-            throw new InvalidQueryError({ reason: `"alias" value has to be a string. "${typeof key}" given` });
-        }
-        if (key.includes('.') || value.includes('.')) {
-            throw new InvalidQueryError({ reason: `"alias" key/value can't contain a period character \`.\`` });
-        }
-    }
+	if (isPlainObject(alias) === false) {
+		throw new InvalidQueryError({ reason: `"alias" has to be an object` });
+	}
+	for (const [key, value] of Object.entries(alias)) {
+		if (typeof key !== "string") {
+			throw new InvalidQueryError({ reason: `"alias" key has to be a string. "${typeof key}" given` });
+		}
+		if (typeof value !== "string") {
+			throw new InvalidQueryError({ reason: `"alias" value has to be a string. "${typeof key}" given` });
+		}
+		if (key.includes(".") || value.includes(".")) {
+			throw new InvalidQueryError({ reason: `"alias" key/value can't contain a period character \`.\`` });
+		}
+	}
 }
 function validateRelationalDepth(query) {
-    const maxRelationalDepth = Number(env['MAX_RELATIONAL_DEPTH']) > 2 ? Number(env['MAX_RELATIONAL_DEPTH']) : 2;
-    // Process the fields in the same way as api/src/utils/get-ast-from-query.ts
-    let fields = ['*'];
-    if (query.fields) {
-        fields = query.fields;
-    }
-    /**
-     * When using aggregate functions, you can't have any other regular fields
-     * selected. This makes sure you never end up in a non-aggregate fields selection error
-     */
-    if (Object.keys(query.aggregate || {}).length > 0) {
-        fields = [];
-    }
-    /**
-     * Similarly, when grouping on a specific field, you can't have other non-aggregated fields.
-     * The group query will override the fields query
-     */
-    if (query.group) {
-        fields = query.group;
-    }
-    fields = uniq(fields);
-    for (const field of fields) {
-        if (getFieldRelationalDepth(field) > maxRelationalDepth) {
-            throw new InvalidQueryError({ reason: 'Max relational depth exceeded' });
-        }
-    }
-    if (query.filter) {
-        const filterRelationalDepth = calculateFieldDepth(query.filter);
-        if (filterRelationalDepth > maxRelationalDepth) {
-            throw new InvalidQueryError({ reason: 'Max relational depth exceeded' });
-        }
-    }
-    if (query.sort) {
-        for (const sort of query.sort) {
-            if (sort.split('.').length > maxRelationalDepth) {
-                throw new InvalidQueryError({ reason: 'Max relational depth exceeded' });
-            }
-        }
-    }
-    if (query.deep) {
-        const deepRelationalDepth = calculateFieldDepth(query.deep, ['_sort']);
-        if (deepRelationalDepth > maxRelationalDepth) {
-            throw new InvalidQueryError({ reason: 'Max relational depth exceeded' });
-        }
-    }
+	const maxRelationalDepth = Number(env["MAX_RELATIONAL_DEPTH"]) > 2 ? Number(env["MAX_RELATIONAL_DEPTH"]) : 2;
+	let fields = ["*"];
+	if (query.fields) {
+		fields = query.fields;
+	}
+	/**
+	* When using aggregate functions, you can't have any other regular fields
+	* selected. This makes sure you never end up in a non-aggregate fields selection error
+	*/
+	if (Object.keys(query.aggregate || {}).length > 0) {
+		fields = [];
+	}
+	/**
+	* Similarly, when grouping on a specific field, you can't have other non-aggregated fields.
+	* The group query will override the fields query
+	*/
+	if (query.group) {
+		fields = query.group;
+	}
+	fields = uniq(fields);
+	for (const field of fields) {
+		if (getFieldRelationalDepth(field) > maxRelationalDepth) {
+			throw new InvalidQueryError({ reason: "Max relational depth exceeded" });
+		}
+	}
+	if (query.filter) {
+		const filterRelationalDepth = calculateFieldDepth(query.filter);
+		if (filterRelationalDepth > maxRelationalDepth) {
+			throw new InvalidQueryError({ reason: "Max relational depth exceeded" });
+		}
+	}
+	if (query.sort) {
+		for (const sort of query.sort) {
+			if (sort.split(".").length > maxRelationalDepth) {
+				throw new InvalidQueryError({ reason: "Max relational depth exceeded" });
+			}
+		}
+	}
+	if (query.deep) {
+		const deepRelationalDepth = calculateFieldDepth(query.deep, ["_sort"]);
+		if (deepRelationalDepth > maxRelationalDepth) {
+			throw new InvalidQueryError({ reason: "Max relational depth exceeded" });
+		}
+	}
 }
+
+//#endregion
+export { validateBoolean, validateGeometry, validateQuery };

package/dist/utils/validate-snapshot.js

@@ -1,77 +1,67 @@
-import { TYPES } from '@directus/constants';
-import { InvalidPayloadError } from '@directus/errors';
-import { DatabaseClients } from '@directus/types';
-import { version } from 'directus/version';
-import Joi from 'joi';
-import { ALIAS_TYPES } from '../constants.js';
-import { getDatabaseClient } from '../database/index.js';
+import { DatabaseClients } from "../packages/types/dist/index.js";
+import { ALIAS_TYPES } from "../constants.js";
+import { getDatabaseClient } from "../database/index.js";
+import { InvalidPayloadError } from "@directus/errors";
+import { TYPES } from "@directus/constants";
+import Joi from "joi";
+import { version } from "directus/version";
+
+//#region src/utils/validate-snapshot.ts
 const snapshotJoiSchema = Joi.object({
-    version: Joi.number().valid(1).required(),
-    directus: Joi.string().required(),
-    vendor: Joi.string()
-        .valid(...DatabaseClients)
-        .optional(),
-    collections: Joi.array().items(Joi.object({
-        collection: Joi.string(),
-        meta: Joi.any(),
-        schema: Joi.object({
-            name: Joi.string(),
-        }),
-    })),
-    fields: Joi.array().items(Joi.object({
-        collection: Joi.string(),
-        field: Joi.string(),
-        meta: Joi.any(),
-        schema: Joi.object({
-            default_value: Joi.any(),
-            max_length: [Joi.number(), Joi.string(), Joi.valid(null)],
-            is_nullable: Joi.bool(),
-        })
-            .unknown()
-            .allow(null),
-        type: Joi.string()
-            .valid(...TYPES, ...ALIAS_TYPES)
-            .allow(null),
-    })),
-    systemFields: Joi.array().items(Joi.object({
-        collection: Joi.string(),
-        field: Joi.string(),
-        schema: Joi.object({
-            is_indexed: Joi.bool(),
-        }),
-    })),
-    relations: Joi.array().items(Joi.object({
-        collection: Joi.string(),
-        field: Joi.string(),
-        meta: Joi.any(),
-        related_collection: Joi.any(),
-        schema: Joi.any(),
-    })),
+	version: Joi.number().valid(1).required(),
+	directus: Joi.string().required(),
+	vendor: Joi.string().valid(...DatabaseClients).optional(),
+	collections: Joi.array().items(Joi.object({
+		collection: Joi.string(),
+		meta: Joi.any(),
+		schema: Joi.object({ name: Joi.string() })
+	})),
+	fields: Joi.array().items(Joi.object({
+		collection: Joi.string(),
+		field: Joi.string(),
+		meta: Joi.any(),
+		schema: Joi.object({
+			default_value: Joi.any(),
+			max_length: [
+				Joi.number(),
+				Joi.string(),
+				Joi.valid(null)
+			],
+			is_nullable: Joi.bool()
+		}).unknown().allow(null),
+		type: Joi.string().valid(...TYPES, ...ALIAS_TYPES).allow(null)
+	})),
+	systemFields: Joi.array().items(Joi.object({
+		collection: Joi.string(),
+		field: Joi.string(),
+		schema: Joi.object({ is_indexed: Joi.bool() })
+	})),
+	relations: Joi.array().items(Joi.object({
+		collection: Joi.string(),
+		field: Joi.string(),
+		meta: Joi.any(),
+		related_collection: Joi.any(),
+		schema: Joi.any()
+	}))
 });
 /**
- * Validates the snapshot against the current instance.
- **/
-export function validateSnapshot(snapshot, force = false) {
-    const { error } = snapshotJoiSchema.validate(snapshot);
-    if (error)
-        throw new InvalidPayloadError({ reason: error.message });
-    // Bypass checks when "force" option is enabled
-    if (force)
-        return;
-    if (snapshot.directus !== version) {
-        throw new InvalidPayloadError({
-            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) {
-        throw new InvalidPayloadError({
-            reason: 'Provided snapshot does not contain the "vendor" property. You can bypass this check by passing the "force" query parameter',
-        });
-    }
-    const currentVendor = getDatabaseClient();
-    if (snapshot.vendor !== currentVendor) {
-        throw new InvalidPayloadError({
-            reason: `Provided snapshot's vendor ${snapshot.vendor} does not match the current instance's vendor ${currentVendor}. You can bypass this check by passing the "force" query parameter`,
-        });
-    }
+* Validates the snapshot against the current instance.
+**/
+function validateSnapshot(snapshot, force = false) {
+	const { error } = snapshotJoiSchema.validate(snapshot);
+	if (error) throw new InvalidPayloadError({ reason: error.message });
+	if (force) return;
+	if (snapshot.directus !== version) {
+		throw new InvalidPayloadError({ 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) {
+		throw new InvalidPayloadError({ reason: "Provided snapshot does not contain the \"vendor\" property. You can bypass this check by passing the \"force\" query parameter" });
+	}
+	const currentVendor = getDatabaseClient();
+	if (snapshot.vendor !== currentVendor) {
+		throw new InvalidPayloadError({ reason: `Provided snapshot's vendor ${snapshot.vendor} does not match the current instance's vendor ${currentVendor}. You can bypass this check by passing the "force" query parameter` });
+	}
 }
+
+//#endregion
+export { validateSnapshot };

package/dist/utils/validate-storage.js

@@ -1,36 +1,38 @@
-import { constants } from 'fs';
-import { access } from 'node:fs/promises';
-import path from 'path';
-import { useEnv } from '@directus/env';
-import { toArray } from '@directus/utils';
-import { getExtensionsPath } from '../extensions/lib/get-extensions-path.js';
-import { useLogger } from '../logger/index.js';
-export async function validateStorage() {
-    const env = useEnv();
-    const logger = useLogger();
-    if (env['DB_CLIENT'] === 'sqlite3') {
-        try {
-            await access(path.dirname(env['DB_FILENAME']), constants.R_OK | constants.W_OK);
-        }
-        catch {
-            logger.warn(`Directory for SQLite database file (${path.resolve(path.dirname(env['DB_FILENAME']))}) is not read/writeable!`);
-        }
-    }
-    const usedStorageDrivers = toArray(env['STORAGE_LOCATIONS']).map((location) => env[`STORAGE_${location.toUpperCase()}_DRIVER`]);
-    if (usedStorageDrivers.includes('local')) {
-        try {
-            await access(env['STORAGE_LOCAL_ROOT'], constants.R_OK | constants.W_OK);
-        }
-        catch {
-            logger.warn(`Upload directory (${path.resolve(env['STORAGE_LOCAL_ROOT'])}) is not read/writeable!`);
-        }
-    }
-    if (!env['EXTENSIONS_LOCATION']) {
-        try {
-            await access(getExtensionsPath(), constants.R_OK);
-        }
-        catch {
-            logger.warn(`Extensions directory (${path.resolve(getExtensionsPath())}) is not readable!`);
-        }
-    }
+import { useLogger } from "../logger/index.js";
+import { getExtensionsPath } from "../extensions/lib/get-extensions-path.js";
+import { access } from "node:fs/promises";
+import path from "path";
+import { useEnv } from "@directus/env";
+import { toArray } from "@directus/utils";
+import { constants } from "fs";
+
+//#region src/utils/validate-storage.ts
+async function validateStorage() {
+	const env = useEnv();
+	const logger = useLogger();
+	if (env["DB_CLIENT"] === "sqlite3") {
+		try {
+			await access(path.dirname(env["DB_FILENAME"]), constants.R_OK | constants.W_OK);
+		} catch {
+			logger.warn(`Directory for SQLite database file (${path.resolve(path.dirname(env["DB_FILENAME"]))}) is not read/writeable!`);
+		}
+	}
+	const usedStorageDrivers = toArray(env["STORAGE_LOCATIONS"]).map((location) => env[`STORAGE_${location.toUpperCase()}_DRIVER`]);
+	if (usedStorageDrivers.includes("local")) {
+		try {
+			await access(env["STORAGE_LOCAL_ROOT"], constants.R_OK | constants.W_OK);
+		} catch {
+			logger.warn(`Upload directory (${path.resolve(env["STORAGE_LOCAL_ROOT"])}) is not read/writeable!`);
+		}
+	}
+	if (!env["EXTENSIONS_LOCATION"]) {
+		try {
+			await access(getExtensionsPath(), constants.R_OK);
+		} catch {
+			logger.warn(`Extensions directory (${path.resolve(getExtensionsPath())}) is not readable!`);
+		}
+	}
 }
+
+//#endregion
+export { validateStorage };