@directus/api 16.0.0 → 17.0.0

package/dist/controllers/permissions.js

@@ -1,6 +1,5 @@
-import { isDirectusError } from '@directus/errors';
+import { ErrorCode, isDirectusError } from '@directus/errors';
 import express from 'express';
-import { ErrorCode } from '@directus/errors';
 import { respond } from '../middleware/respond.js';
 import useCollection from '../middleware/use-collection.js';
 import { validateBatch } from '../middleware/validate-batch.js';
@@ -152,4 +151,14 @@ router.delete('/:pk', asyncHandler(async (req, _res, next) => {
     await service.deleteOne(req.params['pk']);
     return next();
 }), respond);
+router.get('/me/:collection/:pk?', asyncHandler(async (req, res, next) => {
+    const { collection, pk } = req.params;
+    const service = new PermissionsService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    const itemPermissions = await service.getItemPermissions(collection, pk);
+    res.locals['payload'] = { data: itemPermissions };
+    return next();
+}), respond);
 export default router;

package/dist/controllers/utils.js

@@ -1,13 +1,11 @@
+import { InvalidPayloadError, InvalidQueryError, UnsupportedMediaTypeError } from '@directus/errors';
 import argon2 from 'argon2';
 import Busboy from 'busboy';
 import { Router } from 'express';
 import Joi from 'joi';
-import fs from 'node:fs';
-import { createRequire } from 'node:module';
-import { InvalidPayloadError, InvalidQueryError, UnsupportedMediaTypeError } from '@directus/errors';
 import collectionExists from '../middleware/collection-exists.js';
 import { respond } from '../middleware/respond.js';
-import { ExportService } from '../services/import-export/index.js';
+import { ExportService, ImportService } from '../services/import-export.js';
 import { RevisionsService } from '../services/revisions.js';
 import { UtilsService } from '../services/utils.js';
 import asyncHandler from '../utils/async-handler.js';
@@ -66,6 +64,10 @@ router.post('/import/:collection', collectionExists, asyncHandler(async (req, re
     if (req.is('multipart/form-data') === false) {
         throw new UnsupportedMediaTypeError({ mediaType: req.headers['content-type'], where: 'Content-Type header' });
     }
+    const service = new ImportService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
     let headers;
     if (req.headers['content-type']) {
         headers = req.headers;
@@ -78,34 +80,13 @@ router.post('/import/:collection', collectionExists, asyncHandler(async (req, re
     }
     const busboy = Busboy({ headers });
     busboy.on('file', async (_fieldname, fileStream, { mimeType }) => {
-        const { createTmpFile } = await import('@directus/utils/node');
-        const { getWorkerPool } = await import('../worker-pool.js');
-        const tmpFile = await createTmpFile().catch(() => null);
-        if (!tmpFile)
-            throw new Error('Failed to create temporary file for import');
-        fileStream.pipe(fs.createWriteStream(tmpFile.path));
-        fileStream.on('end', async () => {
-            const workerPool = getWorkerPool();
-            const require = createRequire(import.meta.url);
-            const filename = require.resolve('../services/import-export/import-worker');
-            const workerData = {
-                collection: req.params['collection'],
-                mimeType,
-                filePath: tmpFile.path,
-                accountability: req.accountability,
-                schema: req.schema,
-            };
-            try {
-                await workerPool.run(workerData, { filename });
-                res.status(200).end();
-            }
-            catch (error) {
-                next(error);
-            }
-            finally {
-                await tmpFile.cleanup();
-            }
-        });
+        try {
+            await service.import(req.params['collection'], mimeType, fileStream);
+        }
+        catch (err) {
+            return next(err);
+        }
+        return res.status(200).end();
     });
     busboy.on('error', (err) => next(err));
     req.pipe(busboy);

package/dist/middleware/respond.js

@@ -3,7 +3,7 @@ import { parse as parseBytesConfiguration } from 'bytes';
 import { assign } from 'lodash-es';
 import { getCache, setCacheValue } from '../cache.js';
 import { useLogger } from '../logger.js';
-import { ExportService } from '../services/import-export/index.js';
+import { ExportService } from '../services/import-export.js';
 import { VersionsService } from '../services/versions.js';
 import asyncHandler from '../utils/async-handler.js';
 import { getCacheControlHeader } from '../utils/get-cache-headers.js';

package/dist/services/assets.js

@@ -24,7 +24,7 @@ export class AssetsService {
     constructor(options) {
         this.knex = options.knex || getDatabase();
         this.accountability = options.accountability || null;
-        this.filesService = new FilesService(options);
+        this.filesService = new FilesService({ ...options, accountability: null });
         this.authorizationService = new AuthorizationService(options);
     }
     async getAsset(id, transformation, range) {
@@ -46,8 +46,6 @@ export class AssetsService {
             await this.authorizationService.checkAccess('read', 'directus_files', id);
         }
         const file = (await this.filesService.readOne(id, { limit: 1 }));
-        if (!file)
-            throw new ForbiddenError();
         const exists = await storage.location(file.storage).exists(file.filename_disk);
         if (!exists)
             throw new ForbiddenError();

package/dist/services/authorization.d.ts

@@ -13,5 +13,5 @@ export declare class AuthorizationService {
      * Checks if the provided payload matches the configured permissions, and adds the presets to the payload.
      */
     validatePayload(action: PermissionsAction, collection: string, data: Partial<Item>): Partial<Item>;
-    checkAccess(action: PermissionsAction, collection: string, pk: PrimaryKey | PrimaryKey[]): Promise<void>;
+    checkAccess(action: PermissionsAction, collection: string, pk?: PrimaryKey | PrimaryKey[]): Promise<void>;
 }

package/dist/services/authorization.js

@@ -1,9 +1,9 @@
+import { ForbiddenError } from '@directus/errors';
 import { validatePayload } from '@directus/utils';
 import { FailedValidationError, joiValidationErrorItemToErrorExtensions } from '@directus/validation';
 import { cloneDeep, flatten, isArray, isNil, merge, reduce, uniq, uniqWith } from 'lodash-es';
 import { GENERATE_SPECIAL } from '../constants.js';
 import getDatabase from '../database/index.js';
-import { ForbiddenError } from '@directus/errors';
 import { getRelationInfo } from '../utils/get-relation-info.js';
 import { stripFunction } from '../utils/strip-function.js';
 import { ItemsService } from './items.js';
@@ -430,15 +430,27 @@ export class AuthorizationService {
         };
         if (Array.isArray(pk)) {
             const result = await itemsService.readMany(pk, { ...query, limit: pk.length }, { permissionsAction: action });
-            if (!result)
+            // for the unexpected case that the result is not an array (for example due to filter hook)
+            if (!isArray(result))
                 throw new ForbiddenError();
             if (result.length !== pk.length)
                 throw new ForbiddenError();
         }
-        else {
+        else if (pk) {
             const result = await itemsService.readOne(pk, query, { permissionsAction: action });
             if (!result)
                 throw new ForbiddenError();
         }
+        else {
+            query.limit = 1;
+            const result = await itemsService.readByQuery(query, { permissionsAction: action });
+            // for the unexpected case that the result is not an array (for example due to filter hook)
+            if (!isArray(result))
+                throw new ForbiddenError();
+            // for create action, an empty array is expected - for other actions, the first item is expected to be available
+            const access = action === 'create' ? result.length === 0 : !!result[0];
+            if (!access)
+                throw new ForbiddenError();
+        }
     }
 }

package/dist/services/{import-export/index.d.ts → import-export.d.ts}

@@ -2,7 +2,7 @@
 import type { Accountability, File, Query, SchemaOverview } from '@directus/types';
 import type { Knex } from 'knex';
 import type { Readable } from 'node:stream';
-import type { AbstractServiceOptions } from '../../types/index.js';
+import type { AbstractServiceOptions } from '../types/index.js';
 type ExportFormat = 'csv' | 'json' | 'xml' | 'yaml';
 export declare class ImportService {
     knex: Knex;

package/dist/services/{import-export/index.js → import-export.js}

@@ -10,16 +10,16 @@ import { createReadStream } from 'node:fs';
 import { appendFile } from 'node:fs/promises';
 import Papa from 'papaparse';
 import StreamArray from 'stream-json/streamers/StreamArray.js';
-import getDatabase from '../../database/index.js';
-import emitter from '../../emitter.js';
-import { useLogger } from '../../logger.js';
-import { getDateFormatted } from '../../utils/get-date-formatted.js';
-import { Url } from '../../utils/url.js';
-import { userName } from '../../utils/user-name.js';
-import { FilesService } from '../files.js';
-import { ItemsService } from '../items.js';
-import { NotificationsService } from '../notifications.js';
-import { UsersService } from '../users.js';
+import getDatabase from '../database/index.js';
+import emitter from '../emitter.js';
+import { useLogger } from '../logger.js';
+import { getDateFormatted } from '../utils/get-date-formatted.js';
+import { Url } from '../utils/url.js';
+import { userName } from '../utils/user-name.js';
+import { FilesService } from './files.js';
+import { ItemsService } from './items.js';
+import { NotificationsService } from './notifications.js';
+import { UsersService } from './users.js';
 const env = useEnv();
 const logger = useLogger();
 export class ImportService {

package/dist/services/index.d.ts

@@ -10,7 +10,7 @@ export * from './files.js';
 export * from './flows.js';
 export * from './folders.js';
 export * from './graphql/index.js';
-export * from './import-export/index.js';
+export * from './import-export.js';
 export * from './items.js';
 export * from './mail/index.js';
 export * from './meta.js';

package/dist/services/index.js

@@ -10,7 +10,7 @@ export * from './files.js';
 export * from './flows.js';
 export * from './folders.js';
 export * from './graphql/index.js';
-export * from './import-export/index.js';
+export * from './import-export.js';
 export * from './items.js';
 export * from './mail/index.js';
 export * from './meta.js';

package/dist/services/permissions.d.ts

@@ -1,8 +1,8 @@
-import type { PermissionsAction, Query } from '@directus/types';
+import type { ItemPermissions, PermissionsAction, Query } from '@directus/types';
 import type Keyv from 'keyv';
+import type { AbstractServiceOptions, Item, MutationOptions, PrimaryKey } from '../types/index.js';
 import type { QueryOptions } from './items.js';
 import { ItemsService } from './items.js';
-import type { AbstractServiceOptions, Item, MutationOptions, PrimaryKey } from '../types/index.js';
 export declare class PermissionsService extends ItemsService {
     systemCache: Keyv<any>;
     constructor(options: AbstractServiceOptions);
@@ -15,4 +15,5 @@ export declare class PermissionsService extends ItemsService {
     updateMany(keys: PrimaryKey[], data: Partial<Item>, opts?: MutationOptions): Promise<PrimaryKey[]>;
     upsertMany(payloads: Partial<Item>[], opts?: MutationOptions): Promise<PrimaryKey[]>;
     deleteMany(keys: PrimaryKey[], opts?: MutationOptions): Promise<PrimaryKey[]>;
+    getItemPermissions(collection: string, primaryKey?: string): Promise<ItemPermissions>;
 }

package/dist/services/permissions.js

@@ -1,7 +1,9 @@
+import { ForbiddenError } from '@directus/errors';
 import { clearSystemCache, getCache } from '../cache.js';
 import { appAccessMinimalPermissions } from '../database/system-data/app-access-permissions/index.js';
-import { ItemsService } from './items.js';
 import { filterItems } from '../utils/filter-items.js';
+import { AuthorizationService } from './authorization.js';
+import { ItemsService } from './items.js';
 export class PermissionsService extends ItemsService {
     systemCache;
     constructor(options) {
@@ -95,4 +97,77 @@ export class PermissionsService extends ItemsService {
         }
         return res;
     }
+    async getItemPermissions(collection, primaryKey) {
+        if (!this.accountability?.user)
+            throw new ForbiddenError();
+        if (this.accountability?.admin) {
+            return {
+                update: { access: true },
+                delete: { access: true },
+                share: { access: true },
+            };
+        }
+        const itemPermissions = {
+            update: { access: false },
+            delete: { access: false },
+            share: { access: false },
+        };
+        let updateAction = 'update';
+        const schema = this.schema.collections[collection];
+        if (schema?.singleton) {
+            const itemsService = new ItemsService(collection, {
+                knex: this.knex,
+                schema: this.schema,
+            });
+            const query = {
+                fields: [schema.primary],
+                limit: 1,
+            };
+            try {
+                const result = await itemsService.readByQuery(query);
+                if (!result[0])
+                    updateAction = 'create';
+            }
+            catch {
+                updateAction = 'create';
+            }
+        }
+        const authorizationService = new AuthorizationService({
+            knex: this.knex,
+            accountability: this.accountability,
+            schema: this.schema,
+        });
+        await Promise.all(Object.keys(itemPermissions).map((key) => {
+            const action = key;
+            const checkAction = action === 'update' ? updateAction : action;
+            return authorizationService
+                .checkAccess(checkAction, collection, primaryKey)
+                .then(() => (itemPermissions[action].access = true))
+                .catch(() => { });
+        }));
+        if (schema?.singleton && itemPermissions.update.access) {
+            const query = {
+                filter: {
+                    _and: [
+                        ...(this.accountability?.role ? [{ role: { _eq: this.accountability.role } }] : []),
+                        { collection: { _eq: collection } },
+                        { action: { _eq: updateAction } },
+                    ],
+                },
+                fields: ['presets', 'fields'],
+            };
+            try {
+                const result = await this.readByQuery(query);
+                const permission = result[0];
+                if (permission) {
+                    itemPermissions.update.presets = permission['presets'];
+                    itemPermissions.update.fields = permission['fields'];
+                }
+            }
+            catch {
+                // No permission
+            }
+        }
+        return itemPermissions;
+    }
 }

package/dist/services/roles.js

@@ -15,7 +15,7 @@ export class RolesService extends ItemsService {
             .whereNotIn('id', excludeKeys)
             .andWhere({ admin_access: true })
             .first();
-        const otherAdminRolesCount = +(otherAdminRoles?.count || 0);
+        const otherAdminRolesCount = Number(otherAdminRoles?.count ?? 0);
         if (otherAdminRolesCount === 0) {
             throw new UnprocessableContentError({ reason: `You can't delete the last admin role` });
         }
@@ -24,30 +24,98 @@ export class RolesService extends ItemsService {
         const role = await this.knex.select('admin_access').from('directus_roles').where('id', '=', key).first();
         if (!role)
             throw new ForbiddenError();
-        // The users that will now be in this new non-admin role
-        let userKeys = [];
+        const usersBefore = (await this.knex.select('id').from('directus_users').where('role', '=', key)).map((user) => user.id);
+        const usersAdded = [];
+        const usersUpdated = [];
+        const usersCreated = [];
+        const usersRemoved = [];
         if (Array.isArray(users)) {
-            userKeys = users.map((user) => (typeof user === 'string' ? user : user['id'])).filter((id) => id);
+            const usersKept = [];
+            for (const user of users) {
+                if (typeof user === 'string') {
+                    if (usersBefore.includes(user)) {
+                        usersKept.push(user);
+                    }
+                    else {
+                        usersAdded.push({ id: user });
+                    }
+                }
+                else if (user.id) {
+                    if (usersBefore.includes(user.id)) {
+                        usersKept.push(user.id);
+                        usersUpdated.push(user);
+                    }
+                    else {
+                        usersAdded.push(user);
+                    }
+                }
+                else {
+                    usersCreated.push(user);
+                }
+            }
+            usersRemoved.push(...usersBefore.filter((user) => !usersKept.includes(user)));
         }
         else {
-            userKeys = users.update.map((user) => user['id']).filter((id) => id);
+            for (const user of users.update) {
+                if (usersBefore.includes(user['id'])) {
+                    usersUpdated.push(user);
+                }
+                else {
+                    usersAdded.push(user);
+                }
+            }
+            usersCreated.push(...users.create);
+            usersRemoved.push(...users.delete);
+        }
+        if (role.admin_access === false || role.admin_access === 0) {
+            // Admin users might have moved in from other role, thus becoming non-admin
+            if (usersAdded.length > 0) {
+                const otherAdminUsers = await this.knex
+                    .count('*', { as: 'count' })
+                    .from('directus_users')
+                    .leftJoin('directus_roles', 'directus_users.role', 'directus_roles.id')
+                    .whereNotIn('directus_users.id', usersAdded)
+                    .andWhere({ 'directus_roles.admin_access': true, status: 'active' })
+                    .first();
+                const otherAdminUsersCount = Number(otherAdminUsers?.count ?? 0);
+                if (otherAdminUsersCount === 0) {
+                    throw new UnprocessableContentError({ reason: `You can't remove the last admin user from the admin role` });
+                }
+            }
+            return;
         }
-        const usersThatWereInRoleBefore = (await this.knex.select('id').from('directus_users').where('role', '=', key)).map((user) => user.id);
-        const usersThatAreRemoved = usersThatWereInRoleBefore.filter((id) => Array.isArray(users) ? userKeys.includes(id) === false : users.delete.includes(id) === true);
-        const usersThatAreAdded = Array.isArray(users) ? users : users.create;
-        // If the role the users are moved to is an admin-role, and there's at least 1 (new) admin
-        // user, we don't have to check for other admin
-        // users
-        if ((role.admin_access === true || role.admin_access === 1) && usersThatAreAdded.length > 0)
+        // Only added or created new users
+        if (usersUpdated.length === 0 && usersRemoved.length === 0)
+            return;
+        // Active admin user(s) about to be created
+        if (usersCreated.some((user) => !('status' in user) || user.status === 'active'))
             return;
+        const usersDeactivated = [...usersAdded, ...usersUpdated]
+            .filter((user) => 'status' in user && user.status !== 'active')
+            .map((user) => user.id);
+        const usersAddedNonDeactivated = usersAdded
+            .filter((user) => !usersDeactivated.includes(user.id))
+            .map((user) => user.id);
+        // Active user(s) about to become admin
+        if (usersAddedNonDeactivated.length > 0) {
+            const userCount = await this.knex
+                .count('*', { as: 'count' })
+                .from('directus_users')
+                .whereIn('id', usersAddedNonDeactivated)
+                .andWhere({ status: 'active' })
+                .first();
+            if (Number(userCount?.count ?? 0) > 0) {
+                return;
+            }
+        }
         const otherAdminUsers = await this.knex
             .count('*', { as: 'count' })
             .from('directus_users')
-            .whereNotIn('directus_users.id', [...userKeys, ...usersThatAreRemoved])
-            .andWhere({ 'directus_roles.admin_access': true })
             .leftJoin('directus_roles', 'directus_users.role', 'directus_roles.id')
+            .whereNotIn('directus_users.id', [...usersDeactivated, ...usersRemoved])
+            .andWhere({ 'directus_roles.admin_access': true, status: 'active' })
             .first();
-        const otherAdminUsersCount = +(otherAdminUsers?.count || 0);
+        const otherAdminUsersCount = Number(otherAdminUsers?.count ?? 0);
         if (otherAdminUsersCount === 0) {
             throw new UnprocessableContentError({ reason: `You can't remove the last admin user from the admin role` });
         }

package/dist/services/server.js

@@ -41,7 +41,8 @@ export class ServerService {
                 'theme_dark_overrides',
                 'default_language',
                 'public_foreground',
-                'public_background',
+                'public_background.id',
+                'public_background.type',
                 'public_favicon',
                 'public_note',
                 'custom_css',

package/dist/types/items.d.ts

@@ -1,20 +1,12 @@
-/**
- * I know this looks a little silly, but it allows us to explicitly differentiate between when we're
- * expecting an item vs any other generic object.
- */
 import type { DirectusError } from '@directus/errors';
 import type { EventContext } from '@directus/types';
 import type { MutationTracker } from '../services/items.js';
 export type Item = Record<string, any>;
 export type PrimaryKey = string | number;
-export type Alterations = {
-    create: {
-        [key: string]: any;
-    }[];
-    update: {
-        [key: string]: any;
-    }[];
-    delete: (number | string)[];
+export type Alterations<T extends Item = Item, K extends keyof T | undefined = undefined> = {
+    create: Partial<T>[];
+    update: (K extends keyof T ? Partial<T> & Pick<T, K> : Partial<T>)[];
+    delete: (K extends keyof T ? T[K] : PrimaryKey)[];
 };
 export type MutationOptions = {
     /**

package/dist/types/items.js

@@ -1,5 +1 @@
-/**
- * I know this looks a little silly, but it allows us to explicitly differentiate between when we're
- * expecting an item vs any other generic object.
- */
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@directus/api",
-  "version": "16.0.0",
+  "version": "17.0.0",
   "description": "Directus is a real-time API and App dashboard for managing SQL database content",
   "keywords": [
     "directus",
@@ -59,7 +59,7 @@
   ],
   "dependencies": {
     "@authenio/samlify-node-xmllint": "2.0.0",
-    "@aws-sdk/client-ses": "3.504.0",
+    "@aws-sdk/client-ses": "3.511.0",
     "@directus/format-title": "10.1.0",
     "@godaddy/terminus": "4.12.1",
     "@rollup/plugin-alias": "5.1.0",
@@ -85,7 +85,7 @@
     "encodeurl": "1.0.2",
     "eventemitter2": "6.4.9",
     "execa": "8.0.1",
-    "exif-reader": "2.0.0",
+    "exif-reader": "2.0.1",
     "express": "4.18.2",
     "flat": "6.0.1",
     "fs-extra": "11.2.0",
@@ -138,7 +138,6 @@
     "sharp": "0.33.2",
     "snappy": "7.2.2",
     "stream-json": "1.8.0",
-    "tinypool": "0.8.2",
     "tsx": "4.7.0",
     "uuid": "9.0.1",
     "uuid-validate": "0.0.3",
@@ -146,26 +145,26 @@
     "ws": "8.16.0",
     "zod": "3.22.4",
     "zod-validation-error": "3.0.0",
+    "@directus/app": "10.15.0",
+    "@directus/env": "1.0.1",
+    "@directus/extensions": "0.3.1",
+    "@directus/errors": "0.2.2",
     "@directus/constants": "11.0.3",
-    "@directus/env": "1.0.0",
-    "@directus/extensions": "0.3.0",
-    "@directus/extensions-sdk": "10.3.1",
+    "@directus/extensions-sdk": "10.3.2",
     "@directus/memory": "1.0.1",
-    "@directus/app": "10.14.0",
-    "@directus/errors": "0.2.2",
-    "@directus/schema": "11.0.1",
     "@directus/pressure": "1.0.15",
+    "@directus/schema": "11.0.1",
     "@directus/specs": "10.2.6",
-    "@directus/storage-driver-azure": "10.0.16",
     "@directus/storage": "10.0.9",
+    "@directus/storage-driver-azure": "10.0.16",
     "@directus/storage-driver-cloudinary": "10.0.16",
-    "@directus/storage-driver-s3": "10.0.16",
     "@directus/storage-driver-gcs": "10.0.16",
-    "@directus/storage-driver-supabase": "1.0.8",
     "@directus/storage-driver-local": "10.0.16",
+    "@directus/storage-driver-supabase": "1.0.8",
+    "@directus/storage-driver-s3": "10.0.16",
     "@directus/validation": "0.0.11",
-    "directus": "10.9.0",
-    "@directus/utils": "11.0.4"
+    "@directus/utils": "11.0.4",
+    "directus": "10.9.1"
   },
   "devDependencies": {
     "@ngneat/falso": "7.1.1",
@@ -179,7 +178,7 @@
     "@types/destroy": "1.0.3",
     "@types/encodeurl": "1.0.2",
     "@types/express": "4.17.21",
-    "@types/express-serve-static-core": "4.17.42",
+    "@types/express-serve-static-core": "4.17.43",
     "@types/fs-extra": "11.0.4",
     "@types/glob-to-regexp": "0.4.4",
     "@types/inquirer": "9.0.7",
@@ -190,7 +189,7 @@
     "@types/lodash-es": "4.17.12",
     "@types/mime-types": "2.1.4",
     "@types/ms": "0.7.34",
-    "@types/node": "18.19.12",
+    "@types/node": "18.19.14",
     "@types/node-schedule": "2.1.6",
     "@types/nodemailer": "6.4.14",
     "@types/object-hash": "3.0.6",
@@ -208,8 +207,9 @@
     "knex-mock-client": "2.0.1",
     "typescript": "5.3.3",
     "vitest": "1.2.2",
+    "@directus/random": "0.2.5",
     "@directus/tsconfig": "1.0.1",
-    "@directus/types": "11.0.4"
+    "@directus/types": "11.0.5"
   },
   "optionalDependencies": {
     "@keyv/redis": "2.8.4",

package/dist/services/import-export/import-worker.d.ts

@@ -1,9 +0,0 @@
-import type { Accountability, SchemaOverview } from '@directus/types';
-export type ImportWorkerData = {
-    collection: string;
-    mimeType: string;
-    filePath: string;
-    accountability: Accountability | undefined;
-    schema: SchemaOverview;
-};
-export default function ({ collection, mimeType, filePath, accountability, schema }: ImportWorkerData): Promise<void>;

package/dist/services/import-export/import-worker.js

@@ -1,9 +0,0 @@
-import { createReadStream } from 'node:fs';
-import { ImportService } from './index.js';
-export default async function ({ collection, mimeType, filePath, accountability, schema }) {
-    const service = new ImportService({
-        accountability: accountability,
-        schema: schema,
-    });
-    await service.import(collection, mimeType, createReadStream(filePath));
-}

package/dist/worker-pool.d.ts

@@ -1,2 +0,0 @@
-import Tinypool from 'tinypool';
-export declare function getWorkerPool(): Tinypool;

package/dist/worker-pool.js

@@ -1,19 +0,0 @@
-import os from 'node:os';
-import Tinypool from 'tinypool';
-let workerPool;
-export function getWorkerPool() {
-    if (!workerPool) {
-        workerPool = new Tinypool({
-            minThreads: 0,
-            maxQueue: 'auto',
-        });
-        // TODO Workaround currently required for failing CPU count on ARM in Tinypool,
-        //      remove again once fixed upstream
-        if (workerPool.options.maxThreads === 0) {
-            const availableParallelism = os.availableParallelism();
-            workerPool.options.maxThreads = availableParallelism;
-            workerPool.options.maxQueue = availableParallelism ** 2;
-        }
-    }
-    return workerPool;
-}