@directus/api 35.0.2 → 35.1.0

package/dist/services/fields.js

@@ -64,35 +64,25 @@ var FieldsService = class FieldsService {
 	async columnInfo(collection, field) {
 		const schemaCacheIsEnabled = Boolean(env["CACHE_SCHEMA"]);
 		let columnInfo = null;
-		if (schemaCacheIsEnabled) {
-			columnInfo = await getCacheValue(this.schemaCache, "columnInfo");
-		}
+		if (schemaCacheIsEnabled) columnInfo = await getCacheValue(this.schemaCache, "columnInfo");
 		if (!columnInfo) {
 			columnInfo = await this.schemaInspector.columnInfo();
-			if (schemaCacheIsEnabled) {
-				await setCacheValue(this.schemaCache, "columnInfo", columnInfo);
-			}
-		}
-		if (collection) {
-			columnInfo = columnInfo.filter((column) => column.table === collection);
-		}
-		if (field) {
-			return columnInfo.find((column) => column.name === field);
+			if (schemaCacheIsEnabled) await setCacheValue(this.schemaCache, "columnInfo", columnInfo);
 		}
+		if (collection) columnInfo = columnInfo.filter((column) => column.table === collection);
+		if (field) return columnInfo.find((column) => column.name === field);
 		return columnInfo;
 	}
 	async readAll(collection) {
 		let fields;
-		if (this.accountability) {
-			await validateAccess({
-				accountability: this.accountability,
-				action: "read",
-				collection: "directus_fields"
-			}, {
-				schema: this.schema,
-				knex: this.knex
-			});
-		}
+		if (this.accountability) await validateAccess({
+			accountability: this.accountability,
+			action: "read",
+			collection: "directus_fields"
+		}, {
+			schema: this.schema,
+			knex: this.knex
+		});
 		const nonAuthorizedItemsService = new ItemsService("directus_fields", {
 			knex: this.knex,
 			schema: this.schema
@@ -107,51 +97,41 @@ var FieldsService = class FieldsService {
 			fields = await nonAuthorizedItemsService.readByQuery({ limit: -1 });
 			fields.push(...systemFieldRows$1);
 		}
-		const columns = (await this.columnInfo(collection)).map((column) => ({
+		const columnsWithSystem = (await this.columnInfo(collection)).map((column) => ({
 			...column,
 			default_value: getDefaultValue(column, fields.find((field) => field.collection === column.table && field.field === column.name))
-		}));
-		const columnsWithSystem = columns.map((column) => {
+		})).map((column) => {
 			const field = fields.find((field$1) => {
 				return field$1.field === column.name && field$1.collection === column.table;
 			});
 			const type = getLocalType(column, field);
-			const data = {
+			return {
 				collection: column.table,
 				field: column.name,
 				type,
 				schema: column,
 				meta: field || null
 			};
-			return data;
 		});
 		const aliasQuery = this.knex.select("*").from("directus_fields");
-		if (collection) {
-			aliasQuery.andWhere("collection", collection);
-		}
+		if (collection) aliasQuery.andWhere("collection", collection);
 		let aliasFields = [...await this.payloadService.processValues("read", await aliasQuery)];
-		if (collection) {
-			aliasFields.push(...systemFieldRows$1.filter((fieldMeta) => fieldMeta.collection === collection));
-		} else {
-			aliasFields.push(...systemFieldRows$1);
-		}
+		if (collection) aliasFields.push(...systemFieldRows$1.filter((fieldMeta) => fieldMeta.collection === collection));
+		else aliasFields.push(...systemFieldRows$1);
 		aliasFields = aliasFields.filter((field) => {
 			const specials = toArray(field.special);
-			for (const type of ALIAS_TYPES) {
-				if (specials.includes(type)) return true;
-			}
+			for (const type of ALIAS_TYPES) if (specials.includes(type)) return true;
 			return false;
 		});
 		const aliasFieldsAsField = aliasFields.map((field) => {
-			const type = getLocalType(undefined, field);
-			const data = {
+			const type = getLocalType(void 0, field);
+			return {
 				collection: field.collection,
 				field: field.field,
 				type,
 				schema: null,
 				meta: field
 			};
-			return data;
 		});
 		const knownCollections = Object.keys(this.schema.collections);
 		let result = [...columnsWithSystem, ...aliasFieldsAsField].filter((field) => knownCollections.includes(field.collection));
@@ -175,16 +155,10 @@ var FieldsService = class FieldsService {
 			});
 			const allowedFieldsInCollection = {};
 			permissions.forEach((permission) => {
-				if (!allowedFieldsInCollection[permission.collection]) {
-					allowedFieldsInCollection[permission.collection] = new Set();
-				}
-				for (const field of permission.fields ?? []) {
-					allowedFieldsInCollection[permission.collection].add(field);
-				}
+				if (!allowedFieldsInCollection[permission.collection]) allowedFieldsInCollection[permission.collection] = /* @__PURE__ */ new Set();
+				for (const field of permission.fields ?? []) allowedFieldsInCollection[permission.collection].add(field);
 			});
-			if (collection && collection in allowedFieldsInCollection === false) {
-				throw new ForbiddenError();
-			}
+			if (collection && collection in allowedFieldsInCollection === false) throw new ForbiddenError();
 			result = result.filter((field) => {
 				if (field.collection in allowedFieldsInCollection === false) return false;
 				const allowedFields = allowedFieldsInCollection[field.collection];
@@ -192,9 +166,7 @@ var FieldsService = class FieldsService {
 				return allowedFields.has(field.field);
 			});
 		}
-		for (const field of result) {
-			field.type = this.helpers.schema.processFieldType(field);
-		}
+		for (const field of result) field.type = this.helpers.schema.processFieldType(field);
 		return result;
 	}
 	async readOne(collection, field) {
@@ -207,13 +179,12 @@ var FieldsService = class FieldsService {
 				schema: this.schema,
 				knex: this.knex
 			});
-			const policies = await fetchPolicies(this.accountability, {
-				knex: this.knex,
-				schema: this.schema
-			});
 			const permissions = await fetchPermissions({
 				action: "read",
-				policies,
+				policies: await fetchPolicies(this.accountability, {
+					knex: this.knex,
+					schema: this.schema
+				}),
 				collections: [collection],
 				accountability: this.accountability
 			}, {
@@ -221,26 +192,20 @@ var FieldsService = class FieldsService {
 				schema: this.schema
 			});
 			let hasAccess = false;
-			for (const permission of permissions) {
-				if (permission.fields) {
-					if (permission.fields.includes("*") || permission.fields.includes(field)) {
-						hasAccess = true;
-						break;
-					}
+			for (const permission of permissions) if (permission.fields) {
+				if (permission.fields.includes("*") || permission.fields.includes(field)) {
+					hasAccess = true;
+					break;
 				}
 			}
-			if (!hasAccess) {
-				throw new ForbiddenError();
-			}
+			if (!hasAccess) throw new ForbiddenError();
 		}
-		let column = undefined;
+		let column = void 0;
 		let fieldInfo = await this.knex.select("*").from("directus_fields").where({
 			collection,
 			field
 		}).first();
-		if (fieldInfo) {
-			fieldInfo = await this.payloadService.processValues("read", fieldInfo);
-		}
+		if (fieldInfo) fieldInfo = await this.payloadService.processValues("read", fieldInfo);
 		fieldInfo = fieldInfo || systemFieldRows$1.find((fieldMeta) => fieldMeta.collection === collection && fieldMeta.field === field);
 		try {
 			column = await this.columnInfo(collection, field);
@@ -251,33 +216,25 @@ var FieldsService = class FieldsService {
 			...column,
 			default_value: getDefaultValue(column, fieldInfo)
 		} : null;
-		const data = {
+		return {
 			collection,
 			field,
 			type,
 			meta: fieldInfo || null,
 			schema: type === "alias" ? null : columnWithCastDefaultValue
 		};
-		return data;
 	}
 	async createField(collection, field, table, opts) {
-		if (this.accountability && this.accountability.admin !== true) {
-			throw new ForbiddenError();
-		}
+		if (this.accountability && this.accountability.admin !== true) throw new ForbiddenError();
 		const runPostColumnChange = await this.helpers.schema.preColumnChange();
 		const nestedActionEvents = [];
 		try {
-			const exists = field.field in this.schema.collections[collection].fields || isNil(await this.knex.select("id").from("directus_fields").where({
+			if (field.field in this.schema.collections[collection].fields || isNil(await this.knex.select("id").from("directus_fields").where({
 				collection,
 				field: field.field
-			}).first()) === false;
-			if (exists) {
-				throw new InvalidPayloadError({ reason: `Field "${field.field}" already exists in collection "${collection}"` });
-			}
+			}).first()) === false) throw new InvalidPayloadError({ reason: `Field "${field.field}" already exists in collection "${collection}"` });
 			const flagToAdd = this.helpers.date.fieldFlagForField(field.type);
-			if (flagToAdd) {
-				addFieldFlag(field, flagToAdd);
-			}
+			if (flagToAdd) addFieldFlag(field, flagToAdd);
 			let hookAdjustedField = field;
 			const attemptConcurrentIndex = Boolean(opts?.attemptConcurrentIndex);
 			await transaction(this.knex, async (trx) => {
@@ -291,15 +248,10 @@ var FieldsService = class FieldsService {
 					schema: this.schema,
 					accountability: this.accountability
 				}) : field;
-				if (hookAdjustedField.type && ALIAS_TYPES.includes(hookAdjustedField.type) === false) {
-					if (table) {
-						this.addColumnToTable(table, collection, hookAdjustedField, { attemptConcurrentIndex });
-					} else {
-						await trx.schema.alterTable(collection, (table$1) => {
-							this.addColumnToTable(table$1, collection, hookAdjustedField, { attemptConcurrentIndex });
-						});
-					}
-				}
+				if (hookAdjustedField.type && ALIAS_TYPES.includes(hookAdjustedField.type) === false) if (table) this.addColumnToTable(table, collection, hookAdjustedField, { attemptConcurrentIndex });
+				else await trx.schema.alterTable(collection, (table$1) => {
+					this.addColumnToTable(table$1, collection, hookAdjustedField, { attemptConcurrentIndex });
+				});
 				if (hookAdjustedField.meta) {
 					const existingSortRecord = await trx.from("directus_fields").where(hookAdjustedField.meta?.group ? {
 						collection,
@@ -325,25 +277,14 @@ var FieldsService = class FieldsService {
 						accountability: this.accountability
 					}
 				};
-				if (opts?.bypassEmitAction) {
-					opts.bypassEmitAction(actionEvent);
-				} else {
-					nestedActionEvents.push(actionEvent);
-				}
+				if (opts?.bypassEmitAction) opts.bypassEmitAction(actionEvent);
+				else nestedActionEvents.push(actionEvent);
 			});
-			if (attemptConcurrentIndex && hookAdjustedField.type && ALIAS_TYPES.includes(hookAdjustedField.type) === false) {
-				await this.addColumnIndex(collection, hookAdjustedField, { attemptConcurrentIndex });
-			}
+			if (attemptConcurrentIndex && hookAdjustedField.type && ALIAS_TYPES.includes(hookAdjustedField.type) === false) await this.addColumnIndex(collection, hookAdjustedField, { attemptConcurrentIndex });
 		} finally {
-			if (runPostColumnChange) {
-				await this.helpers.schema.postColumnChange();
-			}
-			if (shouldClearCache(this.cache, opts)) {
-				await this.cache.clear();
-			}
-			if (opts?.autoPurgeSystemCache !== false) {
-				await clearSystemCache({ autoPurgeCache: opts?.autoPurgeCache });
-			}
+			if (runPostColumnChange) await this.helpers.schema.postColumnChange();
+			if (shouldClearCache(this.cache, opts)) await this.cache.clear();
+			if (opts?.autoPurgeSystemCache !== false) await clearSystemCache({ autoPurgeCache: opts?.autoPurgeCache });
 			if (opts?.emitEvents !== false && nestedActionEvents.length > 0) {
 				const updatedSchema = await getSchema({ database: this.knex });
 				for (const nestedActionEvent of nestedActionEvents) {
@@ -354,9 +295,7 @@ var FieldsService = class FieldsService {
 		}
 	}
 	async updateField(collection, field, opts) {
-		if (this.accountability && this.accountability.admin !== true) {
-			throw new ForbiddenError();
-		}
+		if (this.accountability && this.accountability.admin !== true) throw new ForbiddenError();
 		const runPostColumnChange = await this.helpers.schema.preColumnChange();
 		const nestedActionEvents = [];
 		if (field.schema && !field.type) {
@@ -376,55 +315,41 @@ var FieldsService = class FieldsService {
 				collection,
 				field: field.field
 			}).first() : null;
-			if (hookAdjustedField.type && (hookAdjustedField.type === "alias" || this.schema.collections[collection].fields[field.field]?.type === "alias") && hookAdjustedField.type !== (this.schema.collections[collection].fields[field.field]?.type ?? "alias")) {
-				throw new InvalidPayloadError({ reason: "Alias type cannot be changed" });
-			}
+			if (hookAdjustedField.type && (hookAdjustedField.type === "alias" || this.schema.collections[collection].fields[field.field]?.type === "alias") && hookAdjustedField.type !== (this.schema.collections[collection].fields[field.field]?.type ?? "alias")) throw new InvalidPayloadError({ reason: "Alias type cannot be changed" });
 			if (hookAdjustedField.schema) {
 				const existingColumn = await this.columnInfo(collection, hookAdjustedField.field);
 				if (existingColumn.is_primary_key) {
-					if (hookAdjustedField.schema?.is_nullable === true) {
-						throw new InvalidPayloadError({ reason: "Primary key cannot be null" });
-					}
+					if (hookAdjustedField.schema?.is_nullable === true) throw new InvalidPayloadError({ reason: "Primary key cannot be null" });
 				}
-				const columnToCompare = opts?.bypassLimits && opts.autoPurgeSystemCache === false ? sanitizeColumn(existingColumn) : existingColumn;
-				if (!isEqual(columnToCompare, hookAdjustedField.schema)) {
-					try {
-						const attemptConcurrentIndex = Boolean(opts?.attemptConcurrentIndex);
-						await transaction(this.knex, async (trx) => {
-							await trx.schema.alterTable(collection, (table) => {
-								if (!hookAdjustedField.schema) return;
-								this.addColumnToTable(table, collection, field, {
-									existing: existingColumn,
-									attemptConcurrentIndex
-								});
-							});
-						});
-						if (attemptConcurrentIndex) {
-							await this.addColumnIndex(collection, field, {
+				if (!isEqual(opts?.bypassLimits && opts.autoPurgeSystemCache === false ? sanitizeColumn(existingColumn) : existingColumn, hookAdjustedField.schema)) try {
+					const attemptConcurrentIndex = Boolean(opts?.attemptConcurrentIndex);
+					await transaction(this.knex, async (trx) => {
+						await trx.schema.alterTable(collection, (table) => {
+							if (!hookAdjustedField.schema) return;
+							this.addColumnToTable(table, collection, field, {
 								existing: existingColumn,
 								attemptConcurrentIndex
 							});
-						}
-					} catch (err) {
-						throw await translateDatabaseError(err, field);
-					}
-				}
-			}
-			if (hookAdjustedField.meta && !isSystemField(collection, hookAdjustedField.field)) {
-				if (record) {
-					await this.itemsService.updateOne(record.id, {
-						...hookAdjustedField.meta,
-						collection,
-						field: hookAdjustedField.field
-					}, { emitEvents: false });
-				} else {
-					await this.itemsService.createOne({
-						...hookAdjustedField.meta,
-						collection,
-						field: hookAdjustedField.field
-					}, { emitEvents: false });
+						});
+					});
+					if (attemptConcurrentIndex) await this.addColumnIndex(collection, field, {
+						existing: existingColumn,
+						attemptConcurrentIndex
+					});
+				} catch (err) {
+					throw await translateDatabaseError(err, field);
 				}
 			}
+			if (hookAdjustedField.meta && !isSystemField(collection, hookAdjustedField.field)) if (record) await this.itemsService.updateOne(record.id, {
+				...hookAdjustedField.meta,
+				collection,
+				field: hookAdjustedField.field
+			}, { emitEvents: false });
+			else await this.itemsService.createOne({
+				...hookAdjustedField.meta,
+				collection,
+				field: hookAdjustedField.field
+			}, { emitEvents: false });
 			const actionEvent = {
 				event: "fields.update",
 				meta: {
@@ -438,22 +363,13 @@ var FieldsService = class FieldsService {
 					accountability: this.accountability
 				}
 			};
-			if (opts?.bypassEmitAction) {
-				opts.bypassEmitAction(actionEvent);
-			} else {
-				nestedActionEvents.push(actionEvent);
-			}
+			if (opts?.bypassEmitAction) opts.bypassEmitAction(actionEvent);
+			else nestedActionEvents.push(actionEvent);
 			return field.field;
 		} finally {
-			if (runPostColumnChange) {
-				await this.helpers.schema.postColumnChange();
-			}
-			if (shouldClearCache(this.cache, opts)) {
-				await this.cache.clear();
-			}
-			if (opts?.autoPurgeSystemCache !== false) {
-				await clearSystemCache({ autoPurgeCache: opts?.autoPurgeCache });
-			}
+			if (runPostColumnChange) await this.helpers.schema.postColumnChange();
+			if (shouldClearCache(this.cache, opts)) await this.cache.clear();
+			if (opts?.autoPurgeSystemCache !== false) await clearSystemCache({ autoPurgeCache: opts?.autoPurgeCache });
 			if (opts?.emitEvents !== false && nestedActionEvents.length > 0) {
 				const updatedSchema = await getSchema({ database: this.knex });
 				for (const nestedActionEvent of nestedActionEvents) {
@@ -468,22 +384,16 @@ var FieldsService = class FieldsService {
 		try {
 			const fieldNames = [];
 			const attemptConcurrentIndex = Boolean(opts?.attemptConcurrentIndex);
-			for (const field of fields) {
-				fieldNames.push(await this.updateField(collection, field, {
-					autoPurgeCache: false,
-					autoPurgeSystemCache: false,
-					bypassEmitAction: (params) => nestedActionEvents.push(params),
-					attemptConcurrentIndex
-				}));
-			}
+			for (const field of fields) fieldNames.push(await this.updateField(collection, field, {
+				autoPurgeCache: false,
+				autoPurgeSystemCache: false,
+				bypassEmitAction: (params) => nestedActionEvents.push(params),
+				attemptConcurrentIndex
+			}));
 			return fieldNames;
 		} finally {
-			if (shouldClearCache(this.cache, opts)) {
-				await this.cache.clear();
-			}
-			if (opts?.autoPurgeSystemCache !== false) {
-				await clearSystemCache({ autoPurgeCache: opts?.autoPurgeCache });
-			}
+			if (shouldClearCache(this.cache, opts)) await this.cache.clear();
+			if (opts?.autoPurgeSystemCache !== false) await clearSystemCache({ autoPurgeCache: opts?.autoPurgeCache });
 			if (opts?.emitEvents !== false && nestedActionEvents.length > 0) {
 				const updatedSchema = await getSchema({ database: this.knex });
 				for (const nestedActionEvent of nestedActionEvents) {
@@ -494,19 +404,15 @@ var FieldsService = class FieldsService {
 		}
 	}
 	async deleteField(collection, field, opts) {
-		if (this.accountability && this.accountability.admin !== true) {
-			throw new ForbiddenError();
-		}
+		if (this.accountability && this.accountability.admin !== true) throw new ForbiddenError();
 		const runPostColumnChange = await this.helpers.schema.preColumnChange();
 		const nestedActionEvents = [];
 		try {
-			if (opts?.emitEvents !== false) {
-				await emitter_default.emitFilter("fields.delete", [field], { collection }, {
-					database: this.knex,
-					schema: this.schema,
-					accountability: this.accountability
-				});
-			}
+			if (opts?.emitEvents !== false) await emitter_default.emitFilter("fields.delete", [field], { collection }, {
+				database: this.knex,
+				schema: this.schema,
+				accountability: this.accountability
+			});
 			await transaction(this.knex, async (trx) => {
 				const relations = getRelations(this.schema.relations, collection, field);
 				const relationsService = new RelationsService({
@@ -526,55 +432,41 @@ var FieldsService = class FieldsService {
 							autoPurgeSystemCache: false,
 							bypassEmitAction: (params) => opts?.bypassEmitAction ? opts.bypassEmitAction(params) : nestedActionEvents.push(params)
 						});
-						if (relation.related_collection && relation.meta?.one_field && relation.related_collection !== collection && relation.meta.one_field !== field) {
-							await fieldsService.deleteField(relation.related_collection, relation.meta.one_field, {
-								autoPurgeCache: false,
-								autoPurgeSystemCache: false,
-								bypassEmitAction: (params) => opts?.bypassEmitAction ? opts.bypassEmitAction(params) : nestedActionEvents.push(params)
-							});
-						}
-					}
-					if (!isM2O && relation.meta?.one_field) {
-						await trx("directus_relations").update({ one_field: null }).where({
-							many_collection: relation.collection,
-							many_field: relation.field
+						if (relation.related_collection && relation.meta?.one_field && relation.related_collection !== collection && relation.meta.one_field !== field) await fieldsService.deleteField(relation.related_collection, relation.meta.one_field, {
+							autoPurgeCache: false,
+							autoPurgeSystemCache: false,
+							bypassEmitAction: (params) => opts?.bypassEmitAction ? opts.bypassEmitAction(params) : nestedActionEvents.push(params)
 						});
 					}
-				}
-				if (this.schema.collections[collection] && field in this.schema.collections[collection].fields && this.schema.collections[collection].fields[field].alias === false) {
-					await trx.schema.table(collection, (table) => {
-						table.dropColumn(field);
+					if (!isM2O && relation.meta?.one_field) await trx("directus_relations").update({ one_field: null }).where({
+						many_collection: relation.collection,
+						many_field: relation.field
 					});
 				}
+				if (this.schema.collections[collection] && field in this.schema.collections[collection].fields && this.schema.collections[collection].fields[field].alias === false) await trx.schema.table(collection, (table) => {
+					table.dropColumn(field);
+				});
 				const { collectionRelationTree, fieldToCollectionList } = await buildCollectionAndFieldRelations(this.schema.relations);
 				const collectionRelationList = getCollectionRelationList(collection, collectionRelationTree);
 				const collectionMetaQuery = trx.queryBuilder().select("collection", "archive_field", "sort_field", "item_duplication_fields").from("directus_collections").where({ collection });
-				if (collectionRelationList.size !== 0) {
-					collectionMetaQuery.orWhere(function() {
-						this.whereIn("collection", Array.from(collectionRelationList)).whereNotNull("item_duplication_fields");
-					});
-				}
-				const collectionMetas = await collectionMetaQuery;
-				const collectionMetaUpdates = getCollectionMetaUpdates(collection, field, collectionMetas, this.schema.collections, fieldToCollectionList);
-				for (const meta of collectionMetaUpdates) {
-					await trx("directus_collections").update(meta.updates).where({ collection: meta.collection });
-				}
+				if (collectionRelationList.size !== 0) collectionMetaQuery.orWhere(function() {
+					this.whereIn("collection", Array.from(collectionRelationList)).whereNotNull("item_duplication_fields");
+				});
+				const collectionMetaUpdates = getCollectionMetaUpdates(collection, field, await collectionMetaQuery, this.schema.collections, fieldToCollectionList);
+				for (const meta of collectionMetaUpdates) await trx("directus_collections").update(meta.updates).where({ collection: meta.collection });
 				const metaRow = await trx.select("collection", "field").from("directus_fields").where({
 					collection,
 					field
 				}).first();
-				if (metaRow) {
-					await trx("directus_fields").update({ group: null }).where({
-						group: metaRow.field,
-						collection: metaRow.collection
-					});
-				}
-				const itemsService = new ItemsService("directus_fields", {
+				if (metaRow) await trx("directus_fields").update({ group: null }).where({
+					group: metaRow.field,
+					collection: metaRow.collection
+				});
+				await new ItemsService("directus_fields", {
 					knex: trx,
 					accountability: this.accountability,
 					schema: this.schema
-				});
-				await itemsService.deleteByQuery({ filter: {
+				}).deleteByQuery({ filter: {
 					collection: { _eq: collection },
 					field: { _eq: field }
 				} }, { emitEvents: false });
@@ -584,11 +476,9 @@ var FieldsService = class FieldsService {
 					"fields",
 					"%" + field + "%"
 				]);
-				if (permissionRows.length > 0) {
-					for (const permissionRow of permissionRows) {
-						const newFields = permissionRow["fields"].split(",").filter((v) => v !== field).join(",");
-						await trx("directus_permissions").update("fields", newFields.length > 0 ? newFields : null).where("id", "=", permissionRow["id"]);
-					}
+				if (permissionRows.length > 0) for (const permissionRow of permissionRows) {
+					const newFields = permissionRow["fields"].split(",").filter((v) => v !== field).join(",");
+					await trx("directus_permissions").update("fields", newFields.length > 0 ? newFields : null).where("id", "=", permissionRow["id"]);
 				}
 			});
 			const actionEvent = {
@@ -603,21 +493,12 @@ var FieldsService = class FieldsService {
 					accountability: this.accountability
 				}
 			};
-			if (opts?.bypassEmitAction) {
-				opts.bypassEmitAction(actionEvent);
-			} else {
-				nestedActionEvents.push(actionEvent);
-			}
+			if (opts?.bypassEmitAction) opts.bypassEmitAction(actionEvent);
+			else nestedActionEvents.push(actionEvent);
 		} finally {
-			if (runPostColumnChange) {
-				await this.helpers.schema.postColumnChange();
-			}
-			if (shouldClearCache(this.cache, opts)) {
-				await this.cache.clear();
-			}
-			if (opts?.autoPurgeSystemCache !== false) {
-				await clearSystemCache({ autoPurgeCache: opts?.autoPurgeCache });
-			}
+			if (runPostColumnChange) await this.helpers.schema.postColumnChange();
+			if (shouldClearCache(this.cache, opts)) await this.cache.clear();
+			if (opts?.autoPurgeSystemCache !== false) await clearSystemCache({ autoPurgeCache: opts?.autoPurgeCache });
 			if (opts?.emitEvents !== false && nestedActionEvents.length > 0) {
 				const updatedSchema = await getSchema({ database: this.knex });
 				for (const nestedActionEvent of nestedActionEvents) {
@@ -631,32 +512,20 @@ var FieldsService = class FieldsService {
 		let column;
 		if (field.type === "alias" || field.type === "unknown") return;
 		const existing = options?.existing ?? null;
-		if (field.schema?.has_auto_increment) {
-			if (field.type === "bigInteger") {
-				column = table.bigIncrements(field.field);
-			} else {
-				column = table.increments(field.field);
-			}
-		} else if (field.type === "string") {
-			column = table.string(field.field, field.schema?.max_length ?? existing?.max_length ?? undefined);
-		} else if (["float", "decimal"].includes(field.type)) {
-			const type = field.type;
-			column = table[type](field.field, field.schema?.numeric_precision ?? existing?.numeric_precision ?? DEFAULT_NUMERIC_PRECISION, field.schema?.numeric_scale ?? existing?.numeric_scale ?? DEFAULT_NUMERIC_SCALE);
-		} else if (field.type === "csv") {
-			column = table.text(field.field);
-		} else if (field.type === "hash") {
-			column = table.string(field.field, 255);
-		} else if (field.type === "dateTime") {
-			column = table.dateTime(field.field, { useTz: false });
-		} else if (field.type === "timestamp") {
-			column = table.timestamp(field.field, { useTz: true });
-		} else if (field.type.startsWith("geometry")) {
-			column = this.helpers.st.createColumn(table, field);
-		} else if (KNEX_TYPES.includes(field.type)) {
-			column = table[field.type](field.field);
-		} else {
-			throw new InvalidPayloadError({ reason: `Illegal type passed: "${field.type}"` });
-		}
+		if (field.schema?.has_auto_increment) if (field.type === "bigInteger") column = table.bigIncrements(field.field);
+		else column = table.increments(field.field);
+		else if (field.type === "string") {
+			const maxLength = field.schema?.max_length !== void 0 ? field.schema.max_length : existing?.max_length ?? void 0;
+			if (maxLength === null && this.helpers.schema.isOneOfClients(["mssql"])) column = table.text(field.field);
+			else column = table.string(field.field, maxLength ?? void 0);
+		} else if (["float", "decimal"].includes(field.type)) column = table[field.type](field.field, field.schema?.numeric_precision ?? existing?.numeric_precision ?? DEFAULT_NUMERIC_PRECISION, field.schema?.numeric_scale ?? existing?.numeric_scale ?? DEFAULT_NUMERIC_SCALE);
+		else if (field.type === "csv") column = table.text(field.field);
+		else if (field.type === "hash") column = table.string(field.field, 255);
+		else if (field.type === "dateTime") column = table.dateTime(field.field, { useTz: false });
+		else if (field.type === "timestamp") column = table.timestamp(field.field, { useTz: true });
+		else if (field.type.startsWith("geometry")) column = this.helpers.st.createColumn(table, field);
+		else if (KNEX_TYPES.includes(field.type)) column = table[field.type](field.field);
+		else throw new InvalidPayloadError({ reason: `Illegal type passed: "${field.type}"` });
 		/**
 		* The column nullability must be set on every alter or it will be dropped
 		* This is due to column.alter() not being incremental per https://knexjs.org/guide/schema-builder.html#alter
@@ -666,46 +535,29 @@ var FieldsService = class FieldsService {
 		* The default value must be set on every alter or it will be dropped
 		* This is due to column.alter() not being incremental per https://knexjs.org/guide/schema-builder.html#alter
 		*/
-		const defaultValue = field.schema?.default_value !== undefined ? field.schema?.default_value : existing?.default_value;
-		if (defaultValue !== undefined) {
+		const defaultValue = field.schema?.default_value !== void 0 ? field.schema?.default_value : existing?.default_value;
+		if (defaultValue !== void 0) {
 			const newDefaultValueIsString = typeof defaultValue === "string";
-			const newDefaultIsNowFunction = newDefaultValueIsString && defaultValue.toLowerCase() === "now()";
-			const newDefaultIsCurrentTimestamp = newDefaultValueIsString && defaultValue === "CURRENT_TIMESTAMP";
-			const newDefaultIsSetToCurrentTime = newDefaultIsNowFunction || newDefaultIsCurrentTimestamp;
+			const newDefaultIsSetToCurrentTime = newDefaultValueIsString && defaultValue.toLowerCase() === "now()" || newDefaultValueIsString && defaultValue === "CURRENT_TIMESTAMP";
 			const newDefaultIsAFunction = newDefaultValueIsString && ALLOWED_DB_DEFAULT_FUNCTIONS.includes(defaultValue);
 			const newDefaultIsTimestampWithPrecision = newDefaultValueIsString && defaultValue.includes("CURRENT_TIMESTAMP(") && defaultValue.includes(")");
-			if (newDefaultIsSetToCurrentTime) {
-				column.defaultTo(this.knex.fn.now());
-			} else if (newDefaultIsTimestampWithPrecision) {
+			if (newDefaultIsSetToCurrentTime) column.defaultTo(this.knex.fn.now());
+			else if (newDefaultIsTimestampWithPrecision) {
 				const precision = defaultValue.match(REGEX_BETWEEN_PARENS)[1];
 				column.defaultTo(this.knex.fn.now(Number(precision)));
-			} else if (newDefaultIsAFunction) {
-				column.defaultTo(this.knex.raw(defaultValue));
-			} else {
-				column.defaultTo(defaultValue);
-			}
+			} else if (newDefaultIsAFunction) column.defaultTo(this.knex.raw(defaultValue));
+			else column.defaultTo(defaultValue);
 		}
-		if (field.schema?.is_primary_key) {
-			column.primary().notNullable();
-		} else if (!existing?.is_primary_key) {
+		if (field.schema?.is_primary_key) column.primary().notNullable();
+		else if (!existing?.is_primary_key) {
 			if (field.schema?.is_unique === true) {
-				if ((!existing || existing.is_unique === false) && !options?.attemptConcurrentIndex) {
-					column.unique({ indexName: this.helpers.schema.generateIndexName("unique", collection, field.field) });
-				}
-			} else if (field.schema?.is_unique === false && existing?.is_unique === true) {
-				table.dropUnique([field.field], this.helpers.schema.generateIndexName("unique", collection, field.field));
-			}
+				if ((!existing || existing.is_unique === false) && !options?.attemptConcurrentIndex) column.unique({ indexName: this.helpers.schema.generateIndexName("unique", collection, field.field) });
+			} else if (field.schema?.is_unique === false && existing?.is_unique === true) table.dropUnique([field.field], this.helpers.schema.generateIndexName("unique", collection, field.field));
 			if (field.schema?.is_indexed === true) {
-				if ((!existing || existing.is_indexed === false) && !options?.attemptConcurrentIndex) {
-					column.index(this.helpers.schema.generateIndexName("index", collection, field.field));
-				}
-			} else if (field.schema?.is_indexed === false && existing?.is_indexed === true) {
-				table.dropIndex([field.field], this.helpers.schema.generateIndexName("index", collection, field.field));
-			}
-		}
-		if (existing) {
-			column.alter();
+				if ((!existing || existing.is_indexed === false) && !options?.attemptConcurrentIndex) column.index(this.helpers.schema.generateIndexName("index", collection, field.field));
+			} else if (field.schema?.is_indexed === false && existing?.is_indexed === true) table.dropIndex([field.field], this.helpers.schema.generateIndexName("index", collection, field.field));
 		}
+		if (existing) column.alter();
 	}
 	async addColumnIndex(collection, field, options) {
 		const attemptConcurrentIndex = Boolean(options?.attemptConcurrentIndex);
@@ -714,18 +566,14 @@ var FieldsService = class FieldsService {
 		if (field.type === "alias" || field.type === "unknown") return;
 		if (field.schema?.is_primary_key || existing?.is_primary_key) return;
 		const helpers = getHelpers(knex);
-		if (field.schema?.is_unique === true && (!existing || existing.is_unique == false)) {
-			await helpers.schema.createIndex(collection, field.field, {
-				unique: true,
-				attemptConcurrentIndex
-			});
-		}
-		if (field.schema?.is_indexed === true && (!existing || existing.is_indexed === false)) {
-			await helpers.schema.createIndex(collection, field.field, {
-				unique: false,
-				attemptConcurrentIndex
-			});
-		}
+		if (field.schema?.is_unique === true && (!existing || existing.is_unique == false)) await helpers.schema.createIndex(collection, field.field, {
+			unique: true,
+			attemptConcurrentIndex
+		});
+		if (field.schema?.is_indexed === true && (!existing || existing.is_indexed === false)) await helpers.schema.createIndex(collection, field.field, {
+			unique: false,
+			attemptConcurrentIndex
+		});
 	}
 };