Fixes #110

Author: u12206050

src/collectionExporter.ts

@@ -17,6 +17,7 @@ const DEFAULT_COLLECTION_EXPORTER_OPTIONS: CollectionExporterOptions = {
 };
 
 class CollectionExporter implements IExporter {
+	protected _itemsService?: IItemsService;
 	protected _getService: () => Promise<IItemsService>;
 	protected collection: string;
 
@@ -39,8 +40,7 @@ class CollectionExporter implements IExporter {
 			...otherOpts,
 		};
 
-		let srv: IItemsService;
-		this._getService = async () => srv || (srv = await getItemsService(collectionName));
+		this._getService = async () => this._itemsService || (this._itemsService = await getItemsService(collectionName));
 
 		this.collection = collectionName;
 
@@ -78,6 +78,12 @@ class CollectionExporter implements IExporter {
 		return this.collection;
 	}
 
+	/** Clear cached schema-dependent state after the DB schema has changed. */
+	public clearCache() {
+		this._itemsService = undefined;
+		this._settings = null;
+	}
+
 	protected _persistQueue = condenseAction(() => this.exportCollectionToFile());
 	public export = () => this._persistQueue();
 

src/exportManager.test.ts

@@ -0,0 +1,61 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { ExportManager } from './exportManager.js';
+import type { IExporter } from './types.js';
+
+describe('ExportManager', () => {
+	it('refreshes schema cache after the schema exporter loads', async () => {
+		let schemaCacheCleared = false;
+		let collectionCacheCleared = false;
+
+		const schemaExporter: IExporter = {
+			name: 'schema',
+			load: async () => {},
+			export: async () => {},
+		};
+
+		const collectionExporter: IExporter = {
+			name: 'custom_collection',
+			load: async () => {},
+			export: async () => {},
+			clearCache: () => {
+				collectionCacheCleared = true;
+			},
+		};
+
+		const manager = new ExportManager(console as any, () => {
+			schemaCacheCleared = true;
+		});
+		manager.addExporter({ watch: [], exporter: schemaExporter });
+		manager.addExporter({ watch: [], exporter: collectionExporter });
+
+		await manager.loadAll();
+
+		assert.strictEqual(schemaCacheCleared, true);
+		assert.strictEqual(collectionCacheCleared, true);
+	});
+
+	it('does not refresh schema cache when loading data only', async () => {
+		let schemaCacheCleared = false;
+		let collectionCacheCleared = false;
+
+		const collectionExporter: IExporter = {
+			name: 'custom_collection',
+			load: async () => {},
+			export: async () => {},
+			clearCache: () => {
+				collectionCacheCleared = true;
+			},
+		};
+
+		const manager = new ExportManager(console as any, () => {
+			schemaCacheCleared = true;
+		});
+		manager.addExporter({ watch: [], exporter: collectionExporter });
+
+		await manager.loadAll();
+
+		assert.strictEqual(schemaCacheCleared, false);
+		assert.strictEqual(collectionCacheCleared, false);
+	});
+});

src/exportManager.ts

@@ -1,12 +1,15 @@
 import type { ApiExtensionContext } from '@directus/extensions';
 import type { ActionHandler } from '@directus/types';
 import { CollectionExporter } from './collectionExporter.js';
-import { ExportCollectionConfig, IExporterConfig, IGetItemsService } from './types';
+import type { ExportCollectionConfig, IExporterConfig, IGetItemsService } from './types';
 
 export class ExportManager {
 	protected exporters: IExporterConfig[] = [];
 
-	constructor(protected logger: ApiExtensionContext['logger']) {}
+	constructor(
+		protected logger: ApiExtensionContext['logger'],
+		protected clearSchemaCache?: () => void
+	) {}
 
 	// FIRST: Add exporters
 	public addExporter(exporterConfig: IExporterConfig) {
@@ -28,11 +31,21 @@ export class ExportManager {
 		await this._loadNextExporter(0, merge);
 	}
 
+	protected refreshSchemaCache() {
+		this.clearSchemaCache?.();
+		for (const { exporter } of this.exporters) {
+			exporter.clearCache?.();
+		}
+	}
+
 	protected async _loadNextExporter(i = 0, merge = false) {
 		if (i >= this.exporters.length) return;
 
 		try {
 			const finishUp = await this.exporters[i]!.exporter.load(merge);
+			if (this.exporters[i]!.exporter.name === 'schema') {
+				this.refreshSchemaCache();
+			}
 			await this._loadNextExporter(i + 1, merge);
 			if (typeof finishUp === 'function') await finishUp();
 		} catch (e) {

src/index.ts

@@ -41,7 +41,7 @@ const registerHook: HookConfig = async ({ action, init }, { env, services, datab
 	let _exportManager: ExportManager;
 
 	const createExportManager = async (dataOnly = false) => {
-		const exportMng = new ExportManager(logger);
+		const exportMng = new ExportManager(logger, clearAdminSchema);
 
 		if (!dataOnly) {
 			exportMng.addExporter({

src/types.ts

@@ -10,6 +10,7 @@ export interface IExporter {
 	name: string;
 	load: (merge?: boolean) => Promise<(() => Promise<void>) | null | void>;
 	export: () => Promise<void>;
+	clearCache?: () => void;
 }
 
 export interface IExporterConfig {

tsconfig.test.json

@@ -26,5 +26,13 @@
 		"rootDir": "./src",
 		"outDir": "./dist-test",
 	},
-	"include": ["src/utils.ts", "src/utils.test.ts", "src/dialects/postgres/utils.ts", "src/dialects/postgres/utils.test.ts"]
+	"include": [
+		"src/utils.ts",
+		"src/utils.test.ts",
+		"src/dialects/postgres/utils.ts",
+		"src/dialects/postgres/utils.test.ts",
+		"src/exportManager.ts",
+		"src/exportManager.test.ts",
+		"src/types.ts"
+	]
 }