directus

1
import type { ApiExtensionType, HybridExtensionType } from '@directus/extensions';
2
import { numberGenerator } from '@directus/utils';
3
import type { Router } from 'express';
4
import { generateHostFunctionReference } from './generate-host-function-reference.js';
5
import {
6
	registerActionGenerator,
7
	registerFilterGenerator,
8
	registerOperationGenerator,
9
	registerRouteGenerator,
10
} from './register/index.js';
11

12
/**
13
 * Generate the JS to run in the isolate to create the extension's entrypoint to the host
14
 *
15
 * @param type - Extension type to generate the entrypoint for
16
 * @param name - Unique name of the extension
17
 * @param endpointRouter - Scoped express router to register endpoint extension in
18
 */
19
export function generateApiExtensionsSandboxEntrypoint(
20
	type: ApiExtensionType | HybridExtensionType,
21
	name: string,
22
	endpointRouter: Router,
23
) {
24
	const index = numberGenerator();
25

26
	const hostFunctions = [];
27

28
	const extensionExport = `const extensionExport = $${index.next().value}.deref();`;
29

30
	if (type === 'hook') {
31
		const code = `
32
			${extensionExport}
33

34
			const filter = ${generateHostFunctionReference(index, ['event', 'handler'], { async: false })}
35
			const action = ${generateHostFunctionReference(index, ['event', 'handler'], { async: false })}
36

37
			return extensionExport({ filter, action });
38
		`;
39

40
		const { register: filter, unregisterFunctions: filterUnregisterFunctions } = registerFilterGenerator();
41
		const { register: action, unregisterFunctions: actionUnregisterFunctions } = registerActionGenerator();
42

43
		hostFunctions.push(filter);
44
		hostFunctions.push(action);
45

46
		const unregisterFunction = async () => {
47
			await Promise.all([...filterUnregisterFunctions, ...actionUnregisterFunctions].map((fn) => fn()));
48
		};
49

50
		return { code, hostFunctions, unregisterFunction };
51
	} else if (type === 'endpoint') {
52
		const code = `
53
			${extensionExport}
54

55
			const registerRoute = ${generateHostFunctionReference(index, ['path', 'method', 'handler'], { async: false })}
56

57
			const router = {
58
				get: (path, handler) => {
59
					registerRoute(path, 'GET', handler);
60
				},
61
				post: (path, handler) => {
62
					registerRoute(path, 'POST', handler);
63
				},
64
				put: (path, handler) => {
65
					registerRoute(path, 'PUT', handler);
66
				},
67
				patch: (path, handler) => {
68
					registerRoute(path, 'PATCH', handler);
69
				},
70
				delete: (path, handler) => {
71
					registerRoute(path, 'DELETE', handler);
72
				}
73
			};
74

75
			return extensionExport(router);
76
		`;
77

78
		const { register, unregisterFunction } = registerRouteGenerator(name, endpointRouter);
79

80
		hostFunctions.push(register);
81

82
		return { code, hostFunctions, unregisterFunction };
83
	} else {
84
		const code = `
85
			${extensionExport}
86

87
			const registerOperation = ${generateHostFunctionReference(index, ['id', 'handler'], { async: false })}
88

89
			const operationConfig = extensionExport;
90

91
			registerOperation(operationConfig.id, operationConfig.handler);
92
		`;
93

94
		const { register, unregisterFunctions } = registerOperationGenerator();
95

96
		hostFunctions.push(register);
97

98
		const unregisterFunction = async () => {
99
			await Promise.all(unregisterFunctions.map((fn) => fn()));
100
		};
101

102
		return { code, hostFunctions, unregisterFunction };
103
	}
104
}
105