@directus/api 9.25.0

package/dist/controllers/assets.js

@@ -0,0 +1,194 @@
+import { parseJSON } from '@directus/utils';
+import contentDisposition from 'content-disposition';
+import { Router } from 'express';
+import { merge, pick } from 'lodash-es';
+import { ASSET_TRANSFORM_QUERY_KEYS, SYSTEM_ASSET_ALLOW_LIST } from '../constants.js';
+import getDatabase from '../database/index.js';
+import env from '../env.js';
+import { InvalidQueryException, RangeNotSatisfiableException } from '../exceptions/index.js';
+import logger from '../logger.js';
+import useCollection from '../middleware/use-collection.js';
+import { AssetsService } from '../services/assets.js';
+import { PayloadService } from '../services/payload.js';
+import { TransformationMethods } from '../types/assets.js';
+import asyncHandler from '../utils/async-handler.js';
+import { getCacheControlHeader } from '../utils/get-cache-headers.js';
+import { getConfigFromEnv } from '../utils/get-config-from-env.js';
+import { getMilliseconds } from '../utils/get-milliseconds.js';
+const router = Router();
+router.use(useCollection('directus_files'));
+router.get('/:pk/:filename?', 
+// Validate query params
+asyncHandler(async (req, res, next) => {
+    const payloadService = new PayloadService('directus_settings', { schema: req.schema });
+    const defaults = { storage_asset_presets: [], storage_asset_transform: 'all' };
+    const database = getDatabase();
+    const savedAssetSettings = await database
+        .select('storage_asset_presets', 'storage_asset_transform')
+        .from('directus_settings')
+        .first();
+    if (savedAssetSettings) {
+        await payloadService.processValues('read', savedAssetSettings);
+    }
+    const assetSettings = savedAssetSettings || defaults;
+    const transformation = pick(req.query, ASSET_TRANSFORM_QUERY_KEYS);
+    if ('key' in transformation && Object.keys(transformation).length > 1) {
+        throw new InvalidQueryException(`You can't combine the "key" query parameter with any other transformation.`);
+    }
+    if ('transforms' in transformation) {
+        let transforms;
+        // Try parse the JSON array
+        try {
+            transforms = parseJSON(transformation['transforms']);
+        }
+        catch {
+            throw new InvalidQueryException(`"transforms" Parameter needs to be a JSON array of allowed transformations.`);
+        }
+        // Check if it is actually an array.
+        if (!Array.isArray(transforms)) {
+            throw new InvalidQueryException(`"transforms" Parameter needs to be a JSON array of allowed transformations.`);
+        }
+        // Check against ASSETS_TRANSFORM_MAX_OPERATIONS
+        if (transforms.length > Number(env['ASSETS_TRANSFORM_MAX_OPERATIONS'])) {
+            throw new InvalidQueryException(`"transforms" Parameter is only allowed ${env['ASSETS_TRANSFORM_MAX_OPERATIONS']} transformations.`);
+        }
+        // Check the transformations are valid
+        transforms.forEach((transform) => {
+            const name = transform[0];
+            if (!TransformationMethods.includes(name)) {
+                throw new InvalidQueryException(`"transforms" Parameter does not allow "${name}" as a transformation.`);
+            }
+        });
+        transformation['transforms'] = transforms;
+    }
+    const systemKeys = SYSTEM_ASSET_ALLOW_LIST.map((transformation) => transformation['key']);
+    const allKeys = [
+        ...systemKeys,
+        ...(assetSettings.storage_asset_presets || []).map((transformation) => transformation['key']),
+    ];
+    // For use in the next request handler
+    res.locals['shortcuts'] = [...SYSTEM_ASSET_ALLOW_LIST, ...(assetSettings.storage_asset_presets || [])];
+    res.locals['transformation'] = transformation;
+    if (Object.keys(transformation).length === 0 ||
+        ('transforms' in transformation && transformation['transforms'].length === 0)) {
+        return next();
+    }
+    if (assetSettings.storage_asset_transform === 'all') {
+        if (transformation['key'] && allKeys.includes(transformation['key']) === false) {
+            throw new InvalidQueryException(`Key "${transformation['key']}" isn't configured.`);
+        }
+        return next();
+    }
+    else if (assetSettings.storage_asset_transform === 'presets') {
+        if (allKeys.includes(transformation['key']))
+            return next();
+        throw new InvalidQueryException(`Only configured presets can be used in asset generation.`);
+    }
+    else {
+        if (transformation['key'] && systemKeys.includes(transformation['key']))
+            return next();
+        throw new InvalidQueryException(`Dynamic asset generation has been disabled for this project.`);
+    }
+}), asyncHandler(async (req, res, next) => {
+    const helmet = await import('helmet');
+    return helmet.contentSecurityPolicy(merge({
+        useDefaults: false,
+        directives: {
+            defaultSrc: ['none'],
+        },
+    }, getConfigFromEnv('ASSETS_CONTENT_SECURITY_POLICY')))(req, res, next);
+}), 
+// Return file
+asyncHandler(async (req, res) => {
+    const id = req.params['pk'].substring(0, 36);
+    const service = new AssetsService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    const transformation = res.locals['transformation'].key
+        ? res.locals['shortcuts'].find((transformation) => transformation['key'] === res.locals['transformation'].key)
+        : res.locals['transformation'];
+    if (transformation.format === 'auto' && req.headers.accept) {
+        let format = 'jpg';
+        if (req.headers.accept.includes('image/webp')) {
+            format = 'webp';
+        }
+        else if (req.headers.accept.includes('image/avif')) {
+            format = 'avif';
+        }
+        transformation.format = format;
+    }
+    let range = undefined;
+    if (req.headers.range) {
+        const rangeParts = /bytes=([0-9]*)-([0-9]*)/.exec(req.headers.range);
+        if (rangeParts && rangeParts.length > 1) {
+            range = {};
+            if (rangeParts[1]) {
+                range.start = Number(rangeParts[1]);
+                if (Number.isNaN(range.start))
+                    throw new RangeNotSatisfiableException(range);
+            }
+            if (rangeParts[2]) {
+                range.end = Number(rangeParts[2]);
+                if (Number.isNaN(range.end))
+                    throw new RangeNotSatisfiableException(range);
+            }
+        }
+    }
+    const { stream, file, stat } = await service.getAsset(id, transformation, range);
+    const filename = req.params['filename'] ?? file.filename_download;
+    res.attachment(filename);
+    res.setHeader('Content-Type', file.type);
+    res.setHeader('Accept-Ranges', 'bytes');
+    res.setHeader('Cache-Control', getCacheControlHeader(req, getMilliseconds(env['ASSETS_CACHE_TTL']), false, true));
+    const unixTime = Date.parse(file.modified_on);
+    if (!Number.isNaN(unixTime)) {
+        const lastModifiedDate = new Date(unixTime);
+        res.setHeader('Last-Modified', lastModifiedDate.toUTCString());
+    }
+    if (range) {
+        res.setHeader('Content-Range', `bytes ${range.start}-${range.end || stat.size - 1}/${stat.size}`);
+        res.status(206);
+        res.setHeader('Content-Length', (range.end ? range.end + 1 : stat.size) - (range.start || 0));
+    }
+    else {
+        res.setHeader('Content-Length', stat.size);
+    }
+    if ('download' in req.query === false) {
+        res.setHeader('Content-Disposition', contentDisposition(filename, { type: 'inline' }));
+    }
+    if (req.method.toLowerCase() === 'head') {
+        res.status(200);
+        res.setHeader('Accept-Ranges', 'bytes');
+        res.setHeader('Content-Length', stat.size);
+        return res.end();
+    }
+    let isDataSent = false;
+    stream.on('data', (chunk) => {
+        isDataSent = true;
+        res.write(chunk);
+    });
+    stream.on('end', () => {
+        res.end();
+    });
+    stream.on('error', (e) => {
+        logger.error(e, `Couldn't stream file ${file.id} to the client`);
+        if (!isDataSent) {
+            res.removeHeader('Content-Type');
+            res.removeHeader('Content-Disposition');
+            res.removeHeader('Cache-Control');
+            res.status(500).json({
+                errors: [
+                    {
+                        message: 'An unexpected error occurred.',
+                        extensions: {
+                            code: 'INTERNAL_SERVER_ERROR',
+                        },
+                    },
+                ],
+            });
+        }
+    });
+    return undefined;
+}));
+export default router;

package/dist/controllers/auth.d.ts

@@ -0,0 +1,2 @@
+declare const router: import("express-serve-static-core").Router;
+export default router;

package/dist/controllers/auth.js

@@ -0,0 +1,163 @@
+import { Router } from 'express';
+import { createLDAPAuthRouter, createLocalAuthRouter, createOAuth2AuthRouter, createOpenIDAuthRouter, createSAMLAuthRouter, } from '../auth/drivers/index.js';
+import { COOKIE_OPTIONS, DEFAULT_AUTH_PROVIDER } from '../constants.js';
+import env from '../env.js';
+import { InvalidPayloadException } from '../exceptions/index.js';
+import logger from '../logger.js';
+import { respond } from '../middleware/respond.js';
+import { AuthenticationService } from '../services/authentication.js';
+import { UsersService } from '../services/users.js';
+import asyncHandler from '../utils/async-handler.js';
+import { getAuthProviders } from '../utils/get-auth-providers.js';
+import { getIPFromReq } from '../utils/get-ip-from-req.js';
+const router = Router();
+const authProviders = getAuthProviders();
+for (const authProvider of authProviders) {
+    let authRouter;
+    switch (authProvider.driver) {
+        case 'local':
+            authRouter = createLocalAuthRouter(authProvider.name);
+            break;
+        case 'oauth2':
+            authRouter = createOAuth2AuthRouter(authProvider.name);
+            break;
+        case 'openid':
+            authRouter = createOpenIDAuthRouter(authProvider.name);
+            break;
+        case 'ldap':
+            authRouter = createLDAPAuthRouter(authProvider.name);
+            break;
+        case 'saml':
+            authRouter = createSAMLAuthRouter(authProvider.name);
+            break;
+    }
+    if (!authRouter) {
+        logger.warn(`Couldn't create login router for auth provider "${authProvider.name}"`);
+        continue;
+    }
+    router.use(`/login/${authProvider.name}`, authRouter);
+}
+if (!env['AUTH_DISABLE_DEFAULT']) {
+    router.use('/login', createLocalAuthRouter(DEFAULT_AUTH_PROVIDER));
+}
+router.post('/refresh', asyncHandler(async (req, res, next) => {
+    const accountability = {
+        ip: getIPFromReq(req),
+        role: null,
+    };
+    const userAgent = req.get('user-agent');
+    if (userAgent)
+        accountability.userAgent = userAgent;
+    const origin = req.get('origin');
+    if (origin)
+        accountability.origin = origin;
+    const authenticationService = new AuthenticationService({
+        accountability: accountability,
+        schema: req.schema,
+    });
+    const currentRefreshToken = req.body.refresh_token || req.cookies[env['REFRESH_TOKEN_COOKIE_NAME']];
+    if (!currentRefreshToken) {
+        throw new InvalidPayloadException(`"refresh_token" is required in either the JSON payload or Cookie`);
+    }
+    const mode = req.body.mode || (req.body.refresh_token ? 'json' : 'cookie');
+    const { accessToken, refreshToken, expires } = await authenticationService.refresh(currentRefreshToken);
+    const payload = {
+        data: { access_token: accessToken, expires },
+    };
+    if (mode === 'json') {
+        payload['data']['refresh_token'] = refreshToken;
+    }
+    if (mode === 'cookie') {
+        res.cookie(env['REFRESH_TOKEN_COOKIE_NAME'], refreshToken, COOKIE_OPTIONS);
+    }
+    res.locals['payload'] = payload;
+    return next();
+}), respond);
+router.post('/logout', asyncHandler(async (req, res, next) => {
+    const accountability = {
+        ip: getIPFromReq(req),
+        role: null,
+    };
+    const userAgent = req.get('user-agent');
+    if (userAgent)
+        accountability.userAgent = userAgent;
+    const origin = req.get('origin');
+    if (origin)
+        accountability.origin = origin;
+    const authenticationService = new AuthenticationService({
+        accountability: accountability,
+        schema: req.schema,
+    });
+    const currentRefreshToken = req.body.refresh_token || req.cookies[env['REFRESH_TOKEN_COOKIE_NAME']];
+    if (!currentRefreshToken) {
+        throw new InvalidPayloadException(`"refresh_token" is required in either the JSON payload or Cookie`);
+    }
+    await authenticationService.logout(currentRefreshToken);
+    if (req.cookies[env['REFRESH_TOKEN_COOKIE_NAME']]) {
+        res.clearCookie(env['REFRESH_TOKEN_COOKIE_NAME'], {
+            httpOnly: true,
+            domain: env['REFRESH_TOKEN_COOKIE_DOMAIN'],
+            secure: env['REFRESH_TOKEN_COOKIE_SECURE'] ?? false,
+            sameSite: env['REFRESH_TOKEN_COOKIE_SAME_SITE'] || 'strict',
+        });
+    }
+    return next();
+}), respond);
+router.post('/password/request', asyncHandler(async (req, _res, next) => {
+    if (typeof req.body.email !== 'string') {
+        throw new InvalidPayloadException(`"email" field is required.`);
+    }
+    const accountability = {
+        ip: getIPFromReq(req),
+        role: null,
+    };
+    const userAgent = req.get('user-agent');
+    if (userAgent)
+        accountability.userAgent = userAgent;
+    const origin = req.get('origin');
+    if (origin)
+        accountability.origin = origin;
+    const service = new UsersService({ accountability, schema: req.schema });
+    try {
+        await service.requestPasswordReset(req.body.email, req.body.reset_url || null);
+        return next();
+    }
+    catch (err) {
+        if (err instanceof InvalidPayloadException) {
+            throw err;
+        }
+        else {
+            logger.warn(err, `[email] ${err}`);
+            return next();
+        }
+    }
+}), respond);
+router.post('/password/reset', asyncHandler(async (req, _res, next) => {
+    if (typeof req.body.token !== 'string') {
+        throw new InvalidPayloadException(`"token" field is required.`);
+    }
+    if (typeof req.body.password !== 'string') {
+        throw new InvalidPayloadException(`"password" field is required.`);
+    }
+    const accountability = {
+        ip: getIPFromReq(req),
+        role: null,
+    };
+    const userAgent = req.get('user-agent');
+    if (userAgent)
+        accountability.userAgent = userAgent;
+    const origin = req.get('origin');
+    if (origin)
+        accountability.origin = origin;
+    const service = new UsersService({ accountability, schema: req.schema });
+    await service.resetPassword(req.body.token, req.body.password);
+    return next();
+}), respond);
+router.get('/', asyncHandler(async (_req, res, next) => {
+    res.locals['payload'] = {
+        data: getAuthProviders(),
+        disableDefault: env['AUTH_DISABLE_DEFAULT'],
+    };
+    return next();
+}), respond);
+export default router;

package/dist/controllers/collections.d.ts

@@ -0,0 +1,2 @@
+declare const router: import("express-serve-static-core").Router;
+export default router;

package/dist/controllers/collections.js

@@ -0,0 +1,101 @@
+import { Router } from 'express';
+import { ForbiddenException } from '../exceptions/index.js';
+import { respond } from '../middleware/respond.js';
+import { validateBatch } from '../middleware/validate-batch.js';
+import { CollectionsService } from '../services/collections.js';
+import { MetaService } from '../services/meta.js';
+import asyncHandler from '../utils/async-handler.js';
+const router = Router();
+router.post('/', asyncHandler(async (req, res, next) => {
+    const collectionsService = new CollectionsService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    if (Array.isArray(req.body)) {
+        const collectionKey = await collectionsService.createMany(req.body);
+        const records = await collectionsService.readMany(collectionKey);
+        res.locals['payload'] = { data: records || null };
+    }
+    else {
+        const collectionKey = await collectionsService.createOne(req.body);
+        const record = await collectionsService.readOne(collectionKey);
+        res.locals['payload'] = { data: record || null };
+    }
+    return next();
+}), respond);
+const readHandler = asyncHandler(async (req, res, next) => {
+    const collectionsService = new CollectionsService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    const metaService = new MetaService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    let result = [];
+    if (req.body.keys) {
+        result = await collectionsService.readMany(req.body.keys);
+    }
+    else {
+        result = await collectionsService.readByQuery();
+    }
+    const meta = await metaService.getMetaForQuery('directus_collections', {});
+    res.locals['payload'] = { data: result, meta };
+    return next();
+});
+router.get('/', validateBatch('read'), readHandler, respond);
+router.search('/', validateBatch('read'), readHandler, respond);
+router.get('/:collection', asyncHandler(async (req, res, next) => {
+    const collectionsService = new CollectionsService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    const collection = await collectionsService.readOne(req.params['collection']);
+    res.locals['payload'] = { data: collection || null };
+    return next();
+}), respond);
+router.patch('/', asyncHandler(async (req, res, next) => {
+    const collectionsService = new CollectionsService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    const collectionKeys = await collectionsService.updateBatch(req.body);
+    try {
+        const collections = await collectionsService.readMany(collectionKeys);
+        res.locals['payload'] = { data: collections || null };
+    }
+    catch (error) {
+        if (error instanceof ForbiddenException) {
+            return next();
+        }
+        throw error;
+    }
+    return next();
+}), respond);
+router.patch('/:collection', asyncHandler(async (req, res, next) => {
+    const collectionsService = new CollectionsService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    await collectionsService.updateOne(req.params['collection'], req.body);
+    try {
+        const collection = await collectionsService.readOne(req.params['collection']);
+        res.locals['payload'] = { data: collection || null };
+    }
+    catch (error) {
+        if (error instanceof ForbiddenException) {
+            return next();
+        }
+        throw error;
+    }
+    return next();
+}), respond);
+router.delete('/:collection', asyncHandler(async (req, _res, next) => {
+    const collectionsService = new CollectionsService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    await collectionsService.deleteOne(req.params['collection']);
+    return next();
+}), respond);
+export default router;

package/dist/controllers/dashboards.d.ts

@@ -0,0 +1,2 @@
+declare const router: import("express-serve-static-core").Router;
+export default router;

package/dist/controllers/dashboards.js

@@ -0,0 +1,140 @@
+import express from 'express';
+import { ForbiddenException } from '../exceptions/index.js';
+import { respond } from '../middleware/respond.js';
+import useCollection from '../middleware/use-collection.js';
+import { validateBatch } from '../middleware/validate-batch.js';
+import { DashboardsService } from '../services/dashboards.js';
+import { MetaService } from '../services/meta.js';
+import asyncHandler from '../utils/async-handler.js';
+import { sanitizeQuery } from '../utils/sanitize-query.js';
+const router = express.Router();
+router.use(useCollection('directus_dashboards'));
+router.post('/', asyncHandler(async (req, res, next) => {
+    const service = new DashboardsService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    const savedKeys = [];
+    if (Array.isArray(req.body)) {
+        const keys = await service.createMany(req.body);
+        savedKeys.push(...keys);
+    }
+    else {
+        const key = await service.createOne(req.body);
+        savedKeys.push(key);
+    }
+    try {
+        if (Array.isArray(req.body)) {
+            const items = await service.readMany(savedKeys, req.sanitizedQuery);
+            res.locals['payload'] = { data: items };
+        }
+        else {
+            const item = await service.readOne(savedKeys[0], req.sanitizedQuery);
+            res.locals['payload'] = { data: item };
+        }
+    }
+    catch (error) {
+        if (error instanceof ForbiddenException) {
+            return next();
+        }
+        throw error;
+    }
+    return next();
+}), respond);
+const readHandler = asyncHandler(async (req, res, next) => {
+    const service = new DashboardsService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    const metaService = new MetaService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    const records = await service.readByQuery(req.sanitizedQuery);
+    const meta = await metaService.getMetaForQuery(req.collection, req.sanitizedQuery);
+    res.locals['payload'] = { data: records || null, meta };
+    return next();
+});
+router.get('/', validateBatch('read'), readHandler, respond);
+router.search('/', validateBatch('read'), readHandler, respond);
+router.get('/:pk', asyncHandler(async (req, res, next) => {
+    const service = new DashboardsService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    const record = await service.readOne(req.params['pk'], req.sanitizedQuery);
+    res.locals['payload'] = { data: record || null };
+    return next();
+}), respond);
+router.patch('/', validateBatch('update'), asyncHandler(async (req, res, next) => {
+    const service = new DashboardsService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    let keys = [];
+    if (Array.isArray(req.body)) {
+        keys = await service.updateBatch(req.body);
+    }
+    else if (req.body.keys) {
+        keys = await service.updateMany(req.body.keys, req.body.data);
+    }
+    else {
+        const sanitizedQuery = sanitizeQuery(req.body.query, req.accountability);
+        keys = await service.updateByQuery(sanitizedQuery, req.body.data);
+    }
+    try {
+        const result = await service.readMany(keys, req.sanitizedQuery);
+        res.locals['payload'] = { data: result };
+    }
+    catch (error) {
+        if (error instanceof ForbiddenException) {
+            return next();
+        }
+        throw error;
+    }
+    return next();
+}), respond);
+router.patch('/:pk', asyncHandler(async (req, res, next) => {
+    const service = new DashboardsService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    const primaryKey = await service.updateOne(req.params['pk'], req.body);
+    try {
+        const item = await service.readOne(primaryKey, req.sanitizedQuery);
+        res.locals['payload'] = { data: item || null };
+    }
+    catch (error) {
+        if (error instanceof ForbiddenException) {
+            return next();
+        }
+        throw error;
+    }
+    return next();
+}), respond);
+router.delete('/', asyncHandler(async (req, _res, next) => {
+    const service = new DashboardsService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    if (Array.isArray(req.body)) {
+        await service.deleteMany(req.body);
+    }
+    else if (req.body.keys) {
+        await service.deleteMany(req.body.keys);
+    }
+    else {
+        const sanitizedQuery = sanitizeQuery(req.body.query, req.accountability);
+        await service.deleteByQuery(sanitizedQuery);
+    }
+    return next();
+}), respond);
+router.delete('/:pk', asyncHandler(async (req, _res, next) => {
+    const service = new DashboardsService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    await service.deleteOne(req.params['pk']);
+    return next();
+}), respond);
+export default router;

package/dist/controllers/extensions.d.ts

@@ -0,0 +1,2 @@
+declare const router: import("express-serve-static-core").Router;
+export default router;

package/dist/controllers/extensions.js

@@ -0,0 +1,42 @@
+import { EXTENSION_TYPES } from '@directus/constants';
+import { depluralize, isIn } from '@directus/utils';
+import { Router } from 'express';
+import env from '../env.js';
+import { RouteNotFoundException } from '../exceptions/index.js';
+import { getExtensionManager } from '../extensions.js';
+import { respond } from '../middleware/respond.js';
+import asyncHandler from '../utils/async-handler.js';
+import { getCacheControlHeader } from '../utils/get-cache-headers.js';
+import { getMilliseconds } from '../utils/get-milliseconds.js';
+const router = Router();
+router.get('/:type', asyncHandler(async (req, res, next) => {
+    const type = depluralize(req.params['type']);
+    if (!isIn(type, EXTENSION_TYPES)) {
+        throw new RouteNotFoundException(req.path);
+    }
+    const extensionManager = getExtensionManager();
+    const extensions = extensionManager.getExtensionsList(type);
+    res.locals['payload'] = {
+        data: extensions,
+    };
+    return next();
+}), respond);
+router.get('/sources/:chunk', asyncHandler(async (req, res) => {
+    const chunk = req.params['chunk'];
+    const extensionManager = getExtensionManager();
+    let source;
+    if (chunk === 'index.js') {
+        source = extensionManager.getAppExtensions();
+    }
+    else {
+        source = extensionManager.getAppExtensionChunk(chunk);
+    }
+    if (source === null) {
+        throw new RouteNotFoundException(req.path);
+    }
+    res.setHeader('Content-Type', 'application/javascript; charset=UTF-8');
+    res.setHeader('Cache-Control', getCacheControlHeader(req, getMilliseconds(env['EXTENSIONS_CACHE_TTL']), false, false));
+    res.setHeader('Vary', 'Origin, Cache-Control');
+    res.end(source);
+}));
+export default router;

package/dist/controllers/fields.d.ts

@@ -0,0 +1,2 @@
+declare const router: import("express-serve-static-core").Router;
+export default router;