Class FieldsService

api/src/services/fields.ts:68–1053

	.strict();

export class FieldsService {
	knex: Knex;
	helpers: Helpers;
	accountability: Accountability | null;
	itemsService: ItemsService;
	payloadService: PayloadService;
	schemaInspector: SchemaInspector;
	schema: SchemaOverview;
	cache: Keyv<any> | null;
	systemCache: Keyv<any>;
	schemaCache: Keyv<any>;

	constructor(options: AbstractServiceOptions) {
		this.knex = options.knex || getDatabase();
		this.helpers = getHelpers(this.knex);
		this.schemaInspector = options.knex ? createInspector(options.knex) : getSchemaInspector();
		this.accountability = options.accountability || null;
		this.itemsService = new ItemsService('directus_fields', options);
		this.payloadService = new PayloadService('directus_fields', options);
		this.schema = options.schema;

		const { cache, systemCache, localSchemaCache } = getCache();

		this.cache = cache;
		this.systemCache = systemCache;
		this.schemaCache = localSchemaCache;
	}

	async columnInfo(collection?: string): Promise<Column[]>;
	async columnInfo(collection: string, field: string): Promise<Column>;
	async columnInfo(collection?: string, field?: string): Promise<Column | Column[]> {
		const schemaCacheIsEnabled = Boolean(env['CACHE_SCHEMA']);

		let columnInfo: Column[] | null = null;

		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) as Column;
		}

		return columnInfo;
	}