@directus/api 13.1.1 → 13.2.0

package/dist/database/seeds/run.js

@@ -30,7 +30,7 @@ export default async function runSeed(database) {
                     column = tableBuilder.increments();
                 }
                 else if (columnInfo.type === 'csv') {
-                    column = tableBuilder.string(columnName);
+                    column = tableBuilder.text(columnName);
                 }
                 else if (columnInfo.type === 'hash') {
                     column = tableBuilder.string(columnName, 255);

package/dist/extensions/get-extensions.d.ts

@@ -0,0 +1,47 @@
+export declare const getExtensions: () => Promise<(({
+    path: string;
+    name: string;
+    version?: string;
+    host?: string;
+    local: boolean;
+} & {
+    type: "interface" | "display" | "layout" | "module" | "panel";
+    entrypoint: string;
+}) | ({
+    path: string;
+    name: string;
+    version?: string;
+    host?: string;
+    local: boolean;
+} & {
+    type: "endpoint" | "hook";
+    entrypoint: string;
+}) | ({
+    path: string;
+    name: string;
+    version?: string;
+    host?: string;
+    local: boolean;
+} & {
+    type: "operation";
+    entrypoint: {
+        app: string;
+        api: string;
+    };
+}) | ({
+    path: string;
+    name: string;
+    version?: string;
+    host?: string;
+    local: boolean;
+} & {
+    type: "bundle";
+    entrypoint: {
+        app: string;
+        api: string;
+    };
+    entries: {
+        type: "operation" | "interface" | "display" | "endpoint" | "layout" | "module" | "panel" | "hook";
+        name: string;
+    }[];
+}))[]>;

package/dist/extensions/get-extensions.js

@@ -0,0 +1,9 @@
+import { APP_EXTENSION_TYPES } from '@directus/extensions';
+import { getLocalExtensions, getPackageExtensions, resolvePackageExtensions } from '@directus/extensions/node';
+import env from '../env.js';
+export const getExtensions = async () => {
+    const packageExtensions = await getPackageExtensions(env['PACKAGE_FILE_LOCATION']);
+    const localPackageExtensions = await resolvePackageExtensions(env['EXTENSIONS_PATH']);
+    const localExtensions = await getLocalExtensions(env['EXTENSIONS_PATH']);
+    return [...packageExtensions, ...localPackageExtensions, ...localExtensions].filter((extension) => env['SERVE_APP'] || APP_EXTENSION_TYPES.includes(extension.type) === false);
+};

package/dist/extensions/get-shared-deps-mapping.d.ts

@@ -0,0 +1 @@
+export declare const getSharedDepsMapping: (deps: string[]) => Promise<Record<string, string>>;

package/dist/extensions/get-shared-deps-mapping.js

@@ -0,0 +1,26 @@
+import { resolvePackage } from '@directus/utils/node';
+import { escapeRegExp } from 'lodash-es';
+import { readdir } from 'node:fs/promises';
+import path from 'path';
+import env from '../env.js';
+import logger from '../logger.js';
+import { Url } from '../utils/url.js';
+import { dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+export const getSharedDepsMapping = async (deps) => {
+    const appDir = await readdir(path.join(resolvePackage('@directus/app', __dirname), 'dist', 'assets'));
+    const depsMapping = {};
+    for (const dep of deps) {
+        const depRegex = new RegExp(`${escapeRegExp(dep.replace(/\//g, '_'))}\\.[0-9a-f]{8}\\.entry\\.js`);
+        const depName = appDir.find((file) => depRegex.test(file));
+        if (depName) {
+            const depUrl = new Url(env['PUBLIC_URL']).addPath('admin', 'assets', depName);
+            depsMapping[dep] = depUrl.toString({ rootRelative: true });
+        }
+        else {
+            logger.warn(`Couldn't find shared extension dependency "${dep}"`);
+        }
+    }
+    return depsMapping;
+};

package/dist/extensions/index.d.ts

@@ -0,0 +1,2 @@
+import { ExtensionManager } from './manager.js';
+export declare function getExtensionManager(): ExtensionManager;

package/dist/extensions/index.js

@@ -0,0 +1,9 @@
+import { ExtensionManager } from './manager.js';
+let extensionManager;
+export function getExtensionManager() {
+    if (extensionManager) {
+        return extensionManager;
+    }
+    extensionManager = new ExtensionManager();
+    return extensionManager;
+}

package/dist/{extensions.d.ts → extensions/manager.d.ts}

@@ -1,11 +1,7 @@
-import type { Extension, ExtensionInfo, ExtensionType } from '@directus/types';
+import type { Extension, ExtensionType } from '@directus/extensions';
 import { Router } from 'express';
-export declare function getExtensionManager(): ExtensionManager;
-type Options = {
-    schedule: boolean;
-    watch: boolean;
-};
-declare class ExtensionManager {
+import type { Options } from './types.js';
+export declare class ExtensionManager {
     private isLoaded;
     private options;
     private extensions;
@@ -22,7 +18,7 @@ declare class ExtensionManager {
     constructor();
     initialize(options?: Partial<Options>): Promise<void>;
     reload(): void;
-    getExtensionsList(type?: ExtensionType): ExtensionInfo[];
+    getExtensionsList(type?: ExtensionType): import("@directus/extensions").ExtensionInfo[];
     getExtension(name: string): Extension | undefined;
     getAppExtensions(): string | null;
     getAppExtensionChunk(name: string): string | null;
@@ -36,9 +32,7 @@ declare class ExtensionManager {
     private initializeWatcher;
     private closeWatcher;
     private updateWatchedExtensions;
-    private getExtensions;
     private generateExtensionBundle;
-    private getSharedDepsMapping;
     private registerHooks;
     private registerEndpoints;
     private registerOperations;
@@ -48,4 +42,3 @@ declare class ExtensionManager {
     private registerOperation;
     private unregisterApiExtensions;
 }
-export {};

package/dist/{extensions.js → extensions/manager.js}

@@ -1,48 +1,45 @@
-import { APP_EXTENSION_TYPES, APP_SHARED_DEPS, HYBRID_EXTENSION_TYPES, JAVASCRIPT_FILE_EXTS, NESTED_EXTENSION_TYPES, } from '@directus/constants';
+import { JAVASCRIPT_FILE_EXTS } from '@directus/constants';
+import { APP_SHARED_DEPS, HYBRID_EXTENSION_TYPES, NESTED_EXTENSION_TYPES } from '@directus/extensions';
+import { ensureExtensionDirs, generateExtensionsEntrypoint } from '@directus/extensions/node';
 import { isIn, isTypeIn, pluralize } from '@directus/utils';
-import { ensureExtensionDirs, generateExtensionsEntrypoint, getLocalExtensions, getPackageExtensions, pathToRelativeUrl, resolvePackage, resolvePackageExtensions, } from '@directus/utils/node';
+import { pathToRelativeUrl } from '@directus/utils/node';
 import aliasDefault from '@rollup/plugin-alias';
 import nodeResolveDefault from '@rollup/plugin-node-resolve';
 import virtualDefault from '@rollup/plugin-virtual';
 import chokidar, { FSWatcher } from 'chokidar';
 import express, { Router } from 'express';
-import { clone, escapeRegExp } from 'lodash-es';
+import { clone } from 'lodash-es';
 import { readdir } from 'node:fs/promises';
 import { createRequire } from 'node:module';
 import { dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import path from 'path';
 import { rollup } from 'rollup';
-import getDatabase from './database/index.js';
-import emitter, { Emitter } from './emitter.js';
-import env from './env.js';
-import { getFlowManager } from './flows.js';
-import logger from './logger.js';
-import * as services from './services/index.js';
-import getModuleDefault from './utils/get-module-default.js';
-import { getSchema } from './utils/get-schema.js';
-import { JobQueue } from './utils/job-queue.js';
-import { scheduleSynchronizedJob, validateCron } from './utils/schedule.js';
-import { Url } from './utils/url.js';
+import getDatabase from '../database/index.js';
+import emitter, { Emitter } from '../emitter.js';
+import env from '../env.js';
+import { getFlowManager } from '../flows.js';
+import logger from '../logger.js';
+import * as services from '../services/index.js';
+import getModuleDefault from '../utils/get-module-default.js';
+import { getSchema } from '../utils/get-schema.js';
+import { JobQueue } from '../utils/job-queue.js';
+import { scheduleSynchronizedJob, validateCron } from '../utils/schedule.js';
+import { getExtensions } from './get-extensions.js';
+import { getSharedDepsMapping } from './get-shared-deps-mapping.js';
+import { normalizeExtensionInfo } from './normalize-extension-info.js';
+import { wrapEmbeds } from './wrap-embeds.js';
 // Workaround for https://github.com/rollup/plugins/issues/1329
 const virtual = virtualDefault;
 const alias = aliasDefault;
 const nodeResolve = nodeResolveDefault;
 const require = createRequire(import.meta.url);
 const __dirname = dirname(fileURLToPath(import.meta.url));
-let extensionManager;
-export function getExtensionManager() {
-    if (extensionManager) {
-        return extensionManager;
-    }
-    extensionManager = new ExtensionManager();
-    return extensionManager;
-}
 const defaultOptions = {
     schedule: true,
     watch: env['EXTENSIONS_AUTO_RELOAD'] && env['NODE_ENV'] !== 'development',
 };
-class ExtensionManager {
+export class ExtensionManager {
     isLoaded = false;
     options;
     extensions = [];
@@ -111,39 +108,11 @@ class ExtensionManager {
         });
     }
     getExtensionsList(type) {
-        if (type === undefined) {
-            return this.extensions.map(mapInfo);
-        }
-        else {
-            return this.extensions.map(mapInfo).filter((extension) => extension.type === type);
-        }
-        function mapInfo(extension) {
-            const extensionInfo = {
-                name: extension.name,
-                type: extension.type,
-                local: extension.local,
-                entries: [],
-            };
-            if (extension.host)
-                extensionInfo.host = extension.host;
-            if (extension.version)
-                extensionInfo.version = extension.version;
-            if (extension.type === 'bundle') {
-                const bundleExtensionInfo = {
-                    name: extensionInfo.name,
-                    type: 'bundle',
-                    local: extensionInfo.local,
-                    entries: extension.entries.map((entry) => ({
-                        name: entry.name,
-                        type: entry.type,
-                    })),
-                };
-                return bundleExtensionInfo;
-            }
-            else {
-                return extensionInfo;
-            }
+        const extensionInfo = this.extensions.map(normalizeExtensionInfo);
+        if (type) {
+            return extensionInfo.filter((extension) => extension.type === type);
         }
+        return extensionInfo;
     }
     getExtension(name) {
         return this.extensions.find((extension) => extension.name === name);
@@ -162,16 +131,11 @@ class ExtensionManager {
             head: wrapEmbeds('Custom Embed Head', this.hookEmbedsHead),
             body: wrapEmbeds('Custom Embed Body', this.hookEmbedsBody),
         };
-        function wrapEmbeds(label, content) {
-            if (content.length === 0)
-                return '';
-            return `<!-- Start ${label} -->\n${content.join('\n')}\n<!-- End ${label} -->`;
-        }
     }
     async load() {
         try {
             await ensureExtensionDirs(env['EXTENSIONS_PATH'], NESTED_EXTENSION_TYPES);
-            this.extensions = await this.getExtensions();
+            this.extensions = await getExtensions();
         }
         catch (err) {
             logger.warn(`Couldn't load extensions`);
@@ -239,14 +203,8 @@ class ExtensionManager {
             this.watcher.unwatch(removedPackageExtensionPaths);
         }
     }
-    async getExtensions() {
-        const packageExtensions = await getPackageExtensions(env['PACKAGE_FILE_LOCATION']);
-        const localPackageExtensions = await resolvePackageExtensions(env['EXTENSIONS_PATH']);
-        const localExtensions = await getLocalExtensions(env['EXTENSIONS_PATH']);
-        return [...packageExtensions, ...localPackageExtensions, ...localExtensions].filter((extension) => env['SERVE_APP'] || APP_EXTENSION_TYPES.includes(extension.type) === false);
-    }
     async generateExtensionBundle() {
-        const sharedDepsMapping = await this.getSharedDepsMapping(APP_SHARED_DEPS);
+        const sharedDepsMapping = await getSharedDepsMapping(APP_SHARED_DEPS);
         const internalImports = Object.entries(sharedDepsMapping).map(([name, path]) => ({
             find: name,
             replacement: path,
@@ -274,22 +232,6 @@ class ExtensionManager {
         }
         return null;
     }
-    async getSharedDepsMapping(deps) {
-        const appDir = await readdir(path.join(resolvePackage('@directus/app', __dirname), 'dist', 'assets'));
-        const depsMapping = {};
-        for (const dep of deps) {
-            const depRegex = new RegExp(`${escapeRegExp(dep.replace(/\//g, '_'))}\\.[0-9a-f]{8}\\.entry\\.js`);
-            const depName = appDir.find((file) => depRegex.test(file));
-            if (depName) {
-                const depUrl = new Url(env['PUBLIC_URL']).addPath('admin', 'assets', depName);
-                depsMapping[dep] = depUrl.toString({ rootRelative: true });
-            }
-            else {
-                logger.warn(`Couldn't find shared extension dependency "${dep}"`);
-            }
-        }
-        return depsMapping;
-    }
     async registerHooks() {
         const hooks = this.extensions.filter((extension) => extension.type === 'hook');
         for (const hook of hooks) {
@@ -323,9 +265,9 @@ class ExtensionManager {
         }
     }
     async registerOperations() {
-        const internalOperations = await readdir(path.join(__dirname, 'operations'));
+        const internalOperations = await readdir(path.join(__dirname, '..', 'operations'));
         for (const operation of internalOperations) {
-            const operationInstance = await import(`./operations/${operation}/index.js`);
+            const operationInstance = await import(`../operations/${operation}/index.js`);
             const config = getModuleDefault(operationInstance);
             this.registerOperation(config);
         }

package/dist/extensions/normalize-extension-info.d.ts

@@ -0,0 +1,5 @@
+import type { Extension, ExtensionInfo } from '@directus/extensions';
+/**
+ * Creates a standardized extension info object for a given extension
+ */
+export declare const normalizeExtensionInfo: (extension: Extension) => ExtensionInfo;

package/dist/extensions/normalize-extension-info.js

@@ -0,0 +1,30 @@
+/**
+ * Creates a standardized extension info object for a given extension
+ */
+export const normalizeExtensionInfo = (extension) => {
+    const extensionInfo = {
+        name: extension.name,
+        type: extension.type,
+        local: extension.local,
+        entries: [],
+    };
+    if (extension.host)
+        extensionInfo.host = extension.host;
+    if (extension.version)
+        extensionInfo.version = extension.version;
+    if (extension.type === 'bundle') {
+        const bundleExtensionInfo = {
+            name: extensionInfo.name,
+            type: 'bundle',
+            local: extensionInfo.local,
+            entries: extension.entries.map((entry) => ({
+                name: entry.name,
+                type: entry.type,
+            })),
+        };
+        return bundleExtensionInfo;
+    }
+    else {
+        return extensionInfo;
+    }
+};

package/dist/extensions/types.d.ts

@@ -0,0 +1,23 @@
+import type { EndpointConfig, HookConfig, OperationApiConfig } from '@directus/extensions';
+export type BundleConfig = {
+    endpoints: {
+        name: string;
+        config: EndpointConfig;
+    }[];
+    hooks: {
+        name: string;
+        config: HookConfig;
+    }[];
+    operations: {
+        name: string;
+        config: OperationApiConfig;
+    }[];
+};
+export type AppExtensions = string | null;
+export type ApiExtensions = {
+    path: string;
+}[];
+export interface Options {
+    schedule: boolean;
+    watch: boolean;
+}

package/dist/extensions/wrap-embeds.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Wraps an array of passed strings in a set of HTML comments with the given label
+ */
+export declare const wrapEmbeds: (label: string, content: string[]) => string;

package/dist/extensions/wrap-embeds.js

@@ -0,0 +1,8 @@
+/**
+ * Wraps an array of passed strings in a set of HTML comments with the given label
+ */
+export const wrapEmbeds = (label, content) => {
+    if (content.length === 0)
+        return '';
+    return `<!-- Start ${label} -->\n${content.join('\n')}\n<!-- End ${label} -->`;
+};

package/dist/flows.d.ts

@@ -1,4 +1,4 @@
-import type { OperationHandler } from '@directus/types';
+import type { OperationHandler } from '@directus/extensions';
 export declare function getFlowManager(): FlowManager;
 declare class FlowManager {
     private isLoaded;

package/dist/flows.js

@@ -5,7 +5,7 @@ import { get } from 'micromustache';
 import getDatabase from './database/index.js';
 import emitter from './emitter.js';
 import env from './env.js';
-import { ForbiddenError } from './errors/index.js';
+import { ForbiddenError } from '@directus/errors';
 import logger from './logger.js';
 import { getMessenger } from './messenger.js';
 import { ActivityService } from './services/activity.js';

package/dist/middleware/check-ip.js

@@ -1,5 +1,5 @@
 import getDatabase from '../database/index.js';
-import { InvalidIpError } from '../errors/index.js';
+import { InvalidIpError } from '@directus/errors';
 import asyncHandler from '../utils/async-handler.js';
 export const checkIP = asyncHandler(async (req, _res, next) => {
     const database = getDatabase();

package/dist/middleware/collection-exists.js

@@ -2,7 +2,7 @@
  * Check if requested collection exists, and save it to req.collection
  */
 import { systemCollectionRows } from '../database/system-data/collections/index.js';
-import { ForbiddenError } from '../errors/index.js';
+import { ForbiddenError } from '@directus/errors';
 import asyncHandler from '../utils/async-handler.js';
 const collectionExists = asyncHandler(async (req, _res, next) => {
     if (!req.params['collection'])

package/dist/middleware/error-handler.js

@@ -3,7 +3,7 @@ import { toArray } from '@directus/utils';
 import getDatabase from '../database/index.js';
 import emitter from '../emitter.js';
 import env from '../env.js';
-import { ErrorCode, MethodNotAllowedError } from '../errors/index.js';
+import { ErrorCode, MethodNotAllowedError } from '@directus/errors';
 import logger from '../logger.js';
 // Note: keep all 4 parameters here. That's how Express recognizes it's the error handler, even if
 // we don't use next

package/dist/middleware/graphql.js

@@ -1,6 +1,6 @@
 import { parseJSON } from '@directus/utils';
 import { getOperationAST, parse, Source } from 'graphql';
-import { InvalidPayloadError, InvalidQueryError, MethodNotAllowedError } from '../errors/index.js';
+import { InvalidPayloadError, InvalidQueryError, MethodNotAllowedError } from '@directus/errors';
 import { GraphQLValidationError } from '../services/graphql/errors/validation.js';
 import asyncHandler from '../utils/async-handler.js';
 export const parseGraphQL = asyncHandler(async (req, res, next) => {

package/dist/middleware/rate-limiter-global.js

@@ -1,5 +1,5 @@
 import env from '../env.js';
-import { HitRateLimitError } from '../errors/index.js';
+import { HitRateLimitError } from '@directus/errors';
 import logger from '../logger.js';
 import { createRateLimiter } from '../rate-limiter.js';
 import asyncHandler from '../utils/async-handler.js';

package/dist/middleware/rate-limiter-ip.js

@@ -1,5 +1,5 @@
 import env from '../env.js';
-import { HitRateLimitError } from '../errors/index.js';
+import { HitRateLimitError } from '@directus/errors';
 import { createRateLimiter } from '../rate-limiter.js';
 import asyncHandler from '../utils/async-handler.js';
 import { getIPFromReq } from '../utils/get-ip-from-req.js';

package/dist/middleware/respond.js

@@ -2,7 +2,7 @@ import { parse as parseBytesConfiguration } from 'bytes';
 import { getCache, setCacheValue } from '../cache.js';
 import env from '../env.js';
 import logger from '../logger.js';
-import { ExportService } from '../services/import-export.js';
+import { ExportService } from '../services/import-export/index.js';
 import asyncHandler from '../utils/async-handler.js';
 import { getCacheControlHeader } from '../utils/get-cache-headers.js';
 import { getCacheKey } from '../utils/get-cache-key.js';

package/dist/middleware/validate-batch.js

@@ -1,5 +1,5 @@
 import Joi from 'joi';
-import { InvalidPayloadError } from '../errors/index.js';
+import { InvalidPayloadError } from '@directus/errors';
 import asyncHandler from '../utils/async-handler.js';
 import { sanitizeQuery } from '../utils/sanitize-query.js';
 export const validateBatch = (scope) => asyncHandler(async (req, _res, next) => {

package/dist/operations/condition/index.d.ts

@@ -2,5 +2,5 @@ import type { Filter } from '@directus/types';
 type Options = {
     filter: Filter;
 };
-declare const _default: import("@directus/types").OperationApiConfig<Options>;
+declare const _default: import("@directus/extensions").OperationApiConfig<Options>;
 export default _default;

package/dist/operations/condition/index.js

@@ -1,4 +1,5 @@
-import { defineOperationApi, validatePayload } from '@directus/utils';
+import { validatePayload } from '@directus/utils';
+import { defineOperationApi } from '@directus/extensions';
 export default defineOperationApi({
     id: 'condition',
     handler: ({ filter }, { data }) => {

package/dist/operations/exec/index.d.ts

@@ -1,5 +1,5 @@
 type Options = {
     code: string;
 };
-declare const _default: import("@directus/types").OperationApiConfig<Options>;
+declare const _default: import("@directus/extensions").OperationApiConfig<Options>;
 export default _default;

package/dist/operations/exec/index.js

@@ -1,4 +1,4 @@
-import { defineOperationApi } from '@directus/utils';
+import { defineOperationApi } from '@directus/extensions';
 import { createRequire } from 'node:module';
 const require = createRequire(import.meta.url);
 const ivm = require('isolated-vm');

package/dist/operations/item-create/index.d.ts

@@ -4,5 +4,5 @@ type Options = {
     emitEvents: boolean;
     permissions: string;
 };
-declare const _default: import("@directus/types").OperationApiConfig<Options>;
+declare const _default: import("@directus/extensions").OperationApiConfig<Options>;
 export default _default;

package/dist/operations/item-create/index.js

@@ -1,4 +1,5 @@
-import { defineOperationApi, optionToObject, toArray } from '@directus/utils';
+import { defineOperationApi } from '@directus/extensions';
+import { optionToObject, toArray } from '@directus/utils';
 import { ItemsService } from '../../services/items.js';
 import { getAccountabilityForRole } from '../../utils/get-accountability-for-role.js';
 export default defineOperationApi({

package/dist/operations/item-delete/index.d.ts

@@ -6,5 +6,5 @@ type Options = {
     emitEvents: boolean;
     permissions: string;
 };
-declare const _default: import("@directus/types").OperationApiConfig<Options>;
+declare const _default: import("@directus/extensions").OperationApiConfig<Options>;
 export default _default;

package/dist/operations/item-delete/index.js

@@ -1,4 +1,5 @@
-import { defineOperationApi, optionToObject, toArray } from '@directus/utils';
+import { defineOperationApi } from '@directus/extensions';
+import { optionToObject, toArray } from '@directus/utils';
 import { ItemsService } from '../../services/items.js';
 import { getAccountabilityForRole } from '../../utils/get-accountability-for-role.js';
 import { sanitizeQuery } from '../../utils/sanitize-query.js';

package/dist/operations/item-read/index.d.ts

@@ -6,5 +6,5 @@ type Options = {
     emitEvents: boolean;
     permissions: string;
 };
-declare const _default: import("@directus/types").OperationApiConfig<Options>;
+declare const _default: import("@directus/extensions").OperationApiConfig<Options>;
 export default _default;

package/dist/operations/item-read/index.js

@@ -1,4 +1,5 @@
-import { defineOperationApi, optionToObject, toArray } from '@directus/utils';
+import { defineOperationApi } from '@directus/extensions';
+import { optionToObject, toArray } from '@directus/utils';
 import { ItemsService } from '../../services/items.js';
 import { getAccountabilityForRole } from '../../utils/get-accountability-for-role.js';
 import { sanitizeQuery } from '../../utils/sanitize-query.js';

package/dist/operations/item-update/index.d.ts

@@ -7,5 +7,5 @@ type Options = {
     emitEvents: boolean;
     permissions: string;
 };
-declare const _default: import("@directus/types").OperationApiConfig<Options>;
+declare const _default: import("@directus/extensions").OperationApiConfig<Options>;
 export default _default;

package/dist/operations/item-update/index.js

@@ -1,4 +1,5 @@
-import { defineOperationApi, optionToObject, toArray } from '@directus/utils';
+import { defineOperationApi } from '@directus/extensions';
+import { optionToObject, toArray } from '@directus/utils';
 import { ItemsService } from '../../services/items.js';
 import { getAccountabilityForRole } from '../../utils/get-accountability-for-role.js';
 import { sanitizeQuery } from '../../utils/sanitize-query.js';

package/dist/operations/json-web-token/index.d.ts

@@ -6,5 +6,5 @@ type Options = {
     secret?: jwt.Secret;
     options?: any;
 };
-declare const _default: import("@directus/types").OperationApiConfig<Options>;
+declare const _default: import("@directus/extensions").OperationApiConfig<Options>;
 export default _default;

package/dist/operations/json-web-token/index.js

@@ -1,4 +1,5 @@
-import { defineOperationApi, optionToObject, optionToString } from '@directus/utils';
+import { defineOperationApi } from '@directus/extensions';
+import { optionToObject, optionToString } from '@directus/utils';
 import jwt from 'jsonwebtoken';
 export default defineOperationApi({
     id: 'json-web-token',

package/dist/operations/log/index.d.ts

@@ -1,5 +1,5 @@
 type Options = {
     message: unknown;
 };
-declare const _default: import("@directus/types").OperationApiConfig<Options>;
+declare const _default: import("@directus/extensions").OperationApiConfig<Options>;
 export default _default;

package/dist/operations/log/index.js

@@ -1,4 +1,5 @@
-import { defineOperationApi, optionToString } from '@directus/utils';
+import { defineOperationApi } from '@directus/extensions';
+import { optionToString } from '@directus/utils';
 import logger from '../../logger.js';
 export default defineOperationApi({
     id: 'log',