@directus/api 11.1.0 → 12.0.0

package/dist/utils/apply-diff.js

@@ -1,6 +1,6 @@
 import deepDiff from 'deep-diff';
 import { cloneDeep, merge, set } from 'lodash-es';
-import { clearSystemCache } from '../cache.js';
+import { flushCaches } from '../cache.js';
 import { getHelpers } from '../database/helpers/index.js';
 import getDatabase from '../database/index.js';
 import emitter from '../emitter.js';
@@ -246,7 +246,7 @@ export async function applyDiff(currentSnapshot, snapshotDiff, options) {
     if (runPostColumnChange) {
         await helpers.schema.postColumnChange();
     }
-    await clearSystemCache();
+    await flushCaches();
     if (nestedActionEvents.length > 0) {
         const updatedSchema = await getSchema({ database, bypassCache: true });
         for (const nestedActionEvent of nestedActionEvents) {

package/dist/utils/apply-query.js

@@ -3,7 +3,7 @@ import { clone, isPlainObject } from 'lodash-es';
 import { customAlphabet } from 'nanoid/non-secure';
 import validate from 'uuid-validate';
 import { getHelpers } from '../database/helpers/index.js';
-import { InvalidQueryException } from '../exceptions/invalid-query.js';
+import { InvalidQueryError } from '../errors/index.js';
 import { getColumnPath } from './get-column-path.js';
 import { getColumn } from './get-column.js';
 import { getRelationInfo } from './get-relation-info.js';
@@ -78,7 +78,9 @@ function addJoin({ path, collection, aliasMap, rootQuery, schema, relations, kne
             else if (relationType === 'a2o') {
                 const pathScope = pathParts[0].split(':')[1];
                 if (!pathScope) {
-                    throw new InvalidQueryException(`You have to provide a collection scope when sorting or filtering on a many-to-any item`);
+                    throw new InvalidQueryError({
+                        reason: `You have to provide a collection scope when sorting or filtering on a many-to-any item`,
+                    });
                 }
                 rootQuery.leftJoin({ [alias]: pathScope }, (joinClause) => {
                     joinClause
@@ -112,7 +114,9 @@ function addJoin({ path, collection, aliasMap, rootQuery, schema, relations, kne
         else if (relationType === 'a2o') {
             const pathScope = pathParts[0].split(':')[1];
             if (!pathScope) {
-                throw new InvalidQueryException(`You have to provide a collection scope when sorting or filtering on a many-to-any item`);
+                throw new InvalidQueryError({
+                    reason: `You have to provide a collection scope when sorting or filtering on a many-to-any item`,
+                });
             }
             parent = pathScope;
         }
@@ -287,7 +291,9 @@ export function applyFilter(knex, schema, rootQuery, rootFilter, collection, ali
                     }
                 }
                 if (filterPath.includes('_none') || filterPath.includes('_some')) {
-                    throw new InvalidQueryException(`"${filterPath.includes('_none') ? '_none' : '_some'}" can only be used with top level relational alias field`);
+                    throw new InvalidQueryError({
+                        reason: `"${filterPath.includes('_none') ? '_none' : '_some'}" can only be used with top level relational alias field`,
+                    });
                 }
                 const { columnPath, targetCollection, addNestedPkField } = getColumnPath({
                     path: filterPath,
@@ -313,7 +319,7 @@ export function applyFilter(knex, schema, rootQuery, rootFilter, collection, ali
         }
         function validateFilterField(fields, key, collection = 'unknown') {
             if (fields[key] === undefined) {
-                throw new InvalidQueryException(`Invalid filter key "${key}" on "${collection}"`);
+                throw new InvalidQueryError({ reason: `Invalid filter key "${key}" on "${collection}"` });
             }
             return fields[key];
         }
@@ -322,11 +328,15 @@ export function applyFilter(knex, schema, rootQuery, rootFilter, collection, ali
                 filterOperator = filterOperator.slice(1);
             }
             if (!getFilterOperatorsForType(type).includes(filterOperator)) {
-                throw new InvalidQueryException(`"${type}" field type does not contain the "_${filterOperator}" filter operator`);
+                throw new InvalidQueryError({
+                    reason: `"${type}" field type does not contain the "_${filterOperator}" filter operator`,
+                });
             }
             if (special.includes('conceal') &&
                 !getFilterOperatorsForType('hash').includes(filterOperator)) {
-                throw new InvalidQueryException(`Field with "conceal" special does not allow the "_${filterOperator}" filter operator`);
+                throw new InvalidQueryError({
+                    reason: `Field with "conceal" special does not allow the "_${filterOperator}" filter operator`,
+                });
             }
         }
         function applyFilterToQuery(key, operator, compareValue, logical = 'and', originalCollectionName) {

package/dist/utils/get-accountability-for-role.js

@@ -1,4 +1,3 @@
-import { InvalidConfigException } from '../exceptions/index.js';
 import { getPermissions } from './get-permissions.js';
 export async function getAccountabilityForRole(role, context) {
     let generatedAccountability = context.accountability;
@@ -27,7 +26,7 @@ export async function getAccountabilityForRole(role, context) {
             .where({ id: role })
             .first();
         if (!roleInfo) {
-            throw new InvalidConfigException(`Configured role "${role}" isn't a valid role ID or doesn't exist.`);
+            throw new Error(`Configured role "${role}" isn't a valid role ID or doesn't exist.`);
         }
         generatedAccountability = {
             role,

package/dist/utils/get-accountability-for-token.js

@@ -1,7 +1,7 @@
 import getDatabase from '../database/index.js';
-import isDirectusJWT from './is-directus-jwt.js';
-import { InvalidCredentialsException } from '../index.js';
 import env from '../env.js';
+import { InvalidCredentialsError } from '../errors/index.js';
+import isDirectusJWT from './is-directus-jwt.js';
 import { verifyAccessJWT } from './jwt.js';
 export async function getAccountabilityForToken(token, accountability) {
     if (!accountability) {
@@ -38,7 +38,7 @@ export async function getAccountabilityForToken(token, accountability) {
             })
                 .first();
             if (!user) {
-                throw new InvalidCredentialsException();
+                throw new InvalidCredentialsError();
             }
             accountability.user = user.id;
             accountability.role = user.role;

package/dist/utils/get-column-path.js

@@ -1,4 +1,4 @@
-import { InvalidQueryException } from '../exceptions/index.js';
+import { InvalidQueryError } from '../errors/index.js';
 import { getRelationInfo } from './get-relation-info.js';
 /**
  * Converts a Directus field list path to the correct SQL names based on the constructed alias map.
@@ -15,7 +15,7 @@ export function getColumnPath({ path, collection, aliasMap, relations, schema })
         const pathRoot = pathParts[0].split(':')[0];
         const { relation, relationType } = getRelationInfo(relations, parentCollection, pathRoot);
         if (!relation) {
-            throw new InvalidQueryException(`"${parentCollection}.${pathRoot}" is not a relational field`);
+            throw new InvalidQueryError({ reason: `"${parentCollection}.${pathRoot}" is not a relational field` });
         }
         const alias = parentFields ? aliasMap[`${parentFields}.${pathParts[0]}`]?.alias : aliasMap[pathParts[0]]?.alias;
         const remainingParts = pathParts.slice(1);
@@ -23,7 +23,9 @@ export function getColumnPath({ path, collection, aliasMap, relations, schema })
         if (relationType === 'a2o') {
             const pathScope = pathParts[0].split(':')[1];
             if (!pathScope) {
-                throw new InvalidQueryException(`You have to provide a collection scope when sorting on a many-to-any item`);
+                throw new InvalidQueryError({
+                    reason: `You have to provide a collection scope when sorting on a many-to-any item`,
+                });
             }
             parent = pathScope;
         }

package/dist/utils/get-column.js

@@ -1,7 +1,7 @@
 import { REGEX_BETWEEN_PARENS } from '@directus/constants';
 import { getFunctionsForType } from '@directus/utils';
 import { getFunctions } from '../database/helpers/index.js';
-import { InvalidQueryException } from '../exceptions/index.js';
+import { InvalidQueryError } from '../errors/index.js';
 import { applyFunctionToColumnName } from './apply-function-to-column-name.js';
 /**
  * Return column prefixed by table. If column includes functions (like `year(date_created)`), the
@@ -25,7 +25,7 @@ export function getColumn(knex, table, column, alias = applyFunctionToColumnName
             const type = schema?.collections[collectionName]?.fields?.[columnName]?.type ?? 'unknown';
             const allowedFunctions = getFunctionsForType(type);
             if (allowedFunctions.includes(functionName) === false) {
-                throw new InvalidQueryException(`Invalid function specified "${functionName}"`);
+                throw new InvalidQueryError({ reason: `Invalid function specified "${functionName}"` });
             }
             const result = fn[functionName](table, columnName, {
                 type,
@@ -38,7 +38,7 @@ export function getColumn(knex, table, column, alias = applyFunctionToColumnName
             return result;
         }
         else {
-            throw new InvalidQueryException(`Invalid function specified "${functionName}"`);
+            throw new InvalidQueryError({ reason: `Invalid function specified "${functionName}"` });
         }
     }
     if (alias && column !== alias) {

package/dist/utils/get-service.d.ts

@@ -1,4 +1,4 @@
-import { ItemsService } from '../index.js';
+import { ItemsService } from '../services/index.js';
 import type { AbstractServiceOptions } from '../types/services.js';
 /**
  * Select the correct service for the given collection. This allows the individual services to run

package/dist/utils/get-service.js

@@ -1,4 +1,4 @@
-import { ActivityService, DashboardsService, FilesService, FlowsService, FoldersService, ItemsService, NotificationsService, OperationsService, PanelsService, PermissionsService, PresetsService, RevisionsService, RolesService, SettingsService, SharesService, UsersService, WebhooksService, } from '../index.js';
+import { ActivityService, DashboardsService, FilesService, FlowsService, FoldersService, ItemsService, NotificationsService, OperationsService, PanelsService, PermissionsService, PresetsService, RevisionsService, RolesService, SettingsService, SharesService, UsersService, WebhooksService, } from '../services/index.js';
 /**
  * Select the correct service for the given collection. This allows the individual services to run
  * their custom checks (f.e. it allows UsersService to prevent updating TFA secret from outside)

package/dist/utils/jwt.js

@@ -1,5 +1,5 @@
 import jwt from 'jsonwebtoken';
-import { InvalidTokenException, ServiceUnavailableException, TokenExpiredException } from '../exceptions/index.js';
+import { InvalidTokenError, ServiceUnavailableError, TokenExpiredError } from '../errors/index.js';
 export function verifyJWT(token, secret) {
     let payload;
     try {
@@ -9,13 +9,13 @@ export function verifyJWT(token, secret) {
     }
     catch (err) {
         if (err instanceof jwt.TokenExpiredError) {
-            throw new TokenExpiredException();
+            throw new TokenExpiredError();
         }
         else if (err instanceof jwt.JsonWebTokenError) {
-            throw new InvalidTokenException('Token invalid.');
+            throw new InvalidTokenError();
         }
         else {
-            throw new ServiceUnavailableException(`Couldn't verify token.`, { service: 'jwt' });
+            throw new ServiceUnavailableError({ service: 'jwt', reason: `Couldn't verify token.` });
         }
     }
     return payload;
@@ -23,7 +23,7 @@ export function verifyJWT(token, secret) {
 export function verifyAccessJWT(token, secret) {
     const { id, role, app_access, admin_access, share, share_scope } = verifyJWT(token, secret);
     if (role === undefined || app_access === undefined || admin_access === undefined) {
-        throw new InvalidTokenException('Invalid token payload.');
+        throw new InvalidTokenError();
     }
     return { id, role, app_access, admin_access, share, share_scope };
 }

package/dist/utils/validate-diff.js

@@ -1,5 +1,5 @@
 import Joi from 'joi';
-import { InvalidPayloadException } from '../exceptions/invalid-payload.js';
+import { InvalidPayloadError } from '../errors/index.js';
 import { DiffKind } from '../types/snapshot.js';
 const deepDiffSchema = Joi.object({
     kind: Joi.string()
@@ -49,7 +49,7 @@ const applyJoiSchema = Joi.object({
 export function validateApplyDiff(applyDiff, currentSnapshotWithHash) {
     const { error } = applyJoiSchema.validate(applyDiff);
     if (error)
-        throw new InvalidPayloadException(error.message);
+        throw new InvalidPayloadError({ reason: error.message });
     // No changes to apply
     if (applyDiff.diff.collections.length === 0 &&
         applyDiff.diff.fields.length === 0 &&
@@ -64,13 +64,17 @@ export function validateApplyDiff(applyDiff, currentSnapshotWithHash) {
         if (diffCollection.diff[0]?.kind === DiffKind.NEW) {
             const existingCollection = currentSnapshotWithHash.collections.find((c) => c.collection === diffCollection.collection);
             if (existingCollection) {
-                throw new InvalidPayloadException(`Provided diff is trying to create collection "${collection}" but it already exists. Please generate a new diff and try again.`);
+                throw new InvalidPayloadError({
+                    reason: `Provided diff is trying to create collection "${collection}" but it already exists. Please generate a new diff and try again`,
+                });
             }
         }
         else if (diffCollection.diff[0]?.kind === DiffKind.DELETE) {
             const existingCollection = currentSnapshotWithHash.collections.find((c) => c.collection === diffCollection.collection);
             if (!existingCollection) {
-                throw new InvalidPayloadException(`Provided diff is trying to delete collection "${collection}" but it does not exist. Please generate a new diff and try again.`);
+                throw new InvalidPayloadError({
+                    reason: `Provided diff is trying to delete collection "${collection}" but it does not exist. Please generate a new diff and try again`,
+                });
             }
         }
     }
@@ -79,13 +83,17 @@ export function validateApplyDiff(applyDiff, currentSnapshotWithHash) {
         if (diffField.diff[0]?.kind === DiffKind.NEW) {
             const existingField = currentSnapshotWithHash.fields.find((f) => f.collection === diffField.collection && f.field === diffField.field);
             if (existingField) {
-                throw new InvalidPayloadException(`Provided diff is trying to create field "${field}" but it already exists. Please generate a new diff and try again.`);
+                throw new InvalidPayloadError({
+                    reason: `Provided diff is trying to create field "${field}" but it already exists. Please generate a new diff and try again`,
+                });
             }
         }
         else if (diffField.diff[0]?.kind === DiffKind.DELETE) {
             const existingField = currentSnapshotWithHash.fields.find((f) => f.collection === diffField.collection && f.field === diffField.field);
             if (!existingField) {
-                throw new InvalidPayloadException(`Provided diff is trying to delete field "${field}" but it does not exist. Please generate a new diff and try again.`);
+                throw new InvalidPayloadError({
+                    reason: `Provided diff is trying to delete field "${field}" but it does not exist. Please generate a new diff and try again`,
+                });
             }
         }
     }
@@ -96,15 +104,21 @@ export function validateApplyDiff(applyDiff, currentSnapshotWithHash) {
         if (diffRelation.diff[0]?.kind === DiffKind.NEW) {
             const existingRelation = currentSnapshotWithHash.relations.find((r) => r.collection === diffRelation.collection && r.field === diffRelation.field);
             if (existingRelation) {
-                throw new InvalidPayloadException(`Provided diff is trying to create relation "${relation}" but it already exists. Please generate a new diff and try again.`);
+                throw new InvalidPayloadError({
+                    reason: `Provided diff is trying to create relation "${relation}" but it already exists. Please generate a new diff and try again`,
+                });
             }
         }
         else if (diffRelation.diff[0]?.kind === DiffKind.DELETE) {
             const existingRelation = currentSnapshotWithHash.relations.find((r) => r.collection === diffRelation.collection && r.field === diffRelation.field);
             if (!existingRelation) {
-                throw new InvalidPayloadException(`Provided diff is trying to delete relation "${relation}" but it does not exist. Please generate a new diff and try again.`);
+                throw new InvalidPayloadError({
+                    reason: `Provided diff is trying to delete relation "${relation}" but it does not exist. Please generate a new diff and try again`,
+                });
             }
         }
     }
-    throw new InvalidPayloadException(`Provided hash does not match the current instance's schema hash, indicating the schema has changed after this diff was generated. Please generate a new diff and try again.`);
+    throw new InvalidPayloadError({
+        reason: `Provided hash does not match the current instance's schema hash, indicating the schema has changed after this diff was generated. Please generate a new diff and try again`,
+    });
 }

package/dist/utils/validate-keys.js

@@ -1,5 +1,5 @@
+import { ForbiddenError } from '../errors/index.js';
 import validateUUID from 'uuid-validate';
-import { ForbiddenException } from '../exceptions/forbidden.js';
 /**
  * Validate keys based on its type
  */
@@ -12,10 +12,10 @@ export function validateKeys(schema, collection, keyField, keys) {
     else {
         const primaryKeyFieldType = schema.collections[collection]?.fields[keyField]?.type;
         if (primaryKeyFieldType === 'uuid' && !validateUUID(String(keys))) {
-            throw new ForbiddenException();
+            throw new ForbiddenError();
         }
         else if (primaryKeyFieldType === 'integer' && !Number.isInteger(Number(keys))) {
-            throw new ForbiddenException();
+            throw new ForbiddenError();
         }
     }
 }

package/dist/utils/validate-query.d.ts

@@ -1,2 +1,4 @@
 import type { Query } from '@directus/types';
 export declare function validateQuery(query: Query): Query;
+export declare function validateBoolean(value: any, key: string): boolean;
+export declare function validateGeometry(value: any, key: string): boolean;

package/dist/utils/validate-query.js

@@ -2,7 +2,7 @@ import Joi from 'joi';
 import { isPlainObject, uniq } from 'lodash-es';
 import { stringify } from 'wellknown';
 import env from '../env.js';
-import { InvalidQueryException } from '../exceptions/invalid-query.js';
+import { InvalidQueryError } from '../errors/index.js';
 import { calculateFieldDepth } from './calculate-field-depth.js';
 const querySchema = Joi.object({
     fields: Joi.array().items(Joi.string()),
@@ -31,13 +31,13 @@ export function validateQuery(query) {
     }
     validateRelationalDepth(query);
     if (error) {
-        throw new InvalidQueryException(error.message);
+        throw new InvalidQueryError({ reason: error.message });
     }
     return query;
 }
 function validateFilter(filter) {
     if (!filter)
-        throw new InvalidQueryException('Invalid filter object');
+        throw new InvalidQueryError({ reason: 'Invalid filter object' });
     for (const [key, nested] of Object.entries(filter)) {
         if (key === '_and' || key === '_or') {
             nested.forEach(validateFilter);
@@ -73,8 +73,12 @@ function validateFilter(filter) {
                 case '_ncontains':
                 case '_starts_with':
                 case '_nstarts_with':
+                case '_istarts_with':
+                case '_nistarts_with':
                 case '_ends_with':
                 case '_nends_with':
+                case '_iends_with':
+                case '_niends_with':
                 case '_gt':
                 case '_gte':
                 case '_lt':
@@ -100,54 +104,56 @@ function validateFilterPrimitive(value, key) {
         return true;
     if ((typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean' || value instanceof Date) ===
         false) {
-        throw new InvalidQueryException(`The filter value for "${key}" has to be a string, number, or boolean`);
+        throw new InvalidQueryError({ reason: `The filter value for "${key}" has to be a string, number, or boolean` });
     }
     if (typeof value === 'number' && (Number.isNaN(value) || value > Number.MAX_SAFE_INTEGER)) {
-        throw new InvalidQueryException(`The filter value for "${key}" is not a valid number`);
+        throw new InvalidQueryError({ reason: `The filter value for "${key}" is not a valid number` });
     }
     if (typeof value === 'string' && value.length === 0) {
-        throw new InvalidQueryException(`You can't filter for an empty string in "${key}". Use "_empty" or "_nempty" instead`);
+        throw new InvalidQueryError({
+            reason: `You can't filter for an empty string in "${key}". Use "_empty" or "_nempty" instead`,
+        });
     }
     return true;
 }
 function validateList(value, key) {
     if (Array.isArray(value) === false || value.length === 0) {
-        throw new InvalidQueryException(`"${key}" has to be an array of values`);
+        throw new InvalidQueryError({ reason: `"${key}" has to be an array of values` });
     }
     return true;
 }
-function validateBoolean(value, key) {
-    if (value === null)
+export function validateBoolean(value, key) {
+    if (value === null || value === '')
         return true;
     if (typeof value !== 'boolean') {
-        throw new InvalidQueryException(`"${key}" has to be a boolean`);
+        throw new InvalidQueryError({ reason: `"${key}" has to be a boolean` });
     }
     return true;
 }
-function validateGeometry(value, key) {
-    if (value === null)
+export function validateGeometry(value, key) {
+    if (value === null || value === '')
         return true;
     try {
         stringify(value);
     }
     catch {
-        throw new InvalidQueryException(`"${key}" has to be a valid GeoJSON object`);
+        throw new InvalidQueryError({ reason: `"${key}" has to be a valid GeoJSON object` });
     }
     return true;
 }
 function validateAlias(alias) {
     if (isPlainObject(alias) === false) {
-        throw new InvalidQueryException(`"alias" has to be an object`);
+        throw new InvalidQueryError({ reason: `"alias" has to be an object` });
     }
     for (const [key, value] of Object.entries(alias)) {
         if (typeof key !== 'string') {
-            throw new InvalidQueryException(`"alias" key has to be a string. "${typeof key}" given.`);
+            throw new InvalidQueryError({ reason: `"alias" key has to be a string. "${typeof key}" given` });
         }
         if (typeof value !== 'string') {
-            throw new InvalidQueryException(`"alias" value has to be a string. "${typeof key}" given.`);
+            throw new InvalidQueryError({ reason: `"alias" value has to be a string. "${typeof key}" given` });
         }
         if (key.includes('.') || value.includes('.')) {
-            throw new InvalidQueryException(`"alias" key/value can't contain a period character \`.\``);
+            throw new InvalidQueryError({ reason: `"alias" key/value can't contain a period character \`.\`` });
         }
     }
 }
@@ -175,26 +181,26 @@ function validateRelationalDepth(query) {
     fields = uniq(fields);
     for (const field of fields) {
         if (field.split('.').length > maxRelationalDepth) {
-            throw new InvalidQueryException('Max relational depth exceeded.');
+            throw new InvalidQueryError({ reason: 'Max relational depth exceeded' });
         }
     }
     if (query.filter) {
         const filterRelationalDepth = calculateFieldDepth(query.filter);
         if (filterRelationalDepth > maxRelationalDepth) {
-            throw new InvalidQueryException('Max relational depth exceeded.');
+            throw new InvalidQueryError({ reason: 'Max relational depth exceeded' });
         }
     }
     if (query.sort) {
         for (const sort of query.sort) {
             if (sort.split('.').length > maxRelationalDepth) {
-                throw new InvalidQueryException('Max relational depth exceeded.');
+                throw new InvalidQueryError({ reason: 'Max relational depth exceeded' });
             }
         }
     }
     if (query.deep) {
         const deepRelationalDepth = calculateFieldDepth(query.deep, ['_sort']);
         if (deepRelationalDepth > maxRelationalDepth) {
-            throw new InvalidQueryException('Max relational depth exceeded.');
+            throw new InvalidQueryError({ reason: 'Max relational depth exceeded' });
         }
     }
 }

package/dist/utils/validate-snapshot.js

@@ -2,7 +2,7 @@ import { TYPES } from '@directus/constants';
 import Joi from 'joi';
 import { ALIAS_TYPES } from '../constants.js';
 import { getDatabaseClient } from '../database/index.js';
-import { InvalidPayloadException } from '../exceptions/invalid-payload.js';
+import { InvalidPayloadError } from '../errors/index.js';
 import { DatabaseClients } from '../types/index.js';
 import { version as currentDirectusVersion } from './package.js';
 const snapshotJoiSchema = Joi.object({
@@ -47,18 +47,24 @@ const snapshotJoiSchema = Joi.object({
 export function validateSnapshot(snapshot, force = false) {
     const { error } = snapshotJoiSchema.validate(snapshot);
     if (error)
-        throw new InvalidPayloadException(error.message);
+        throw new InvalidPayloadError({ reason: error.message });
     // Bypass checks when "force" option is enabled
     if (force)
         return;
     if (snapshot.directus !== currentDirectusVersion) {
-        throw new InvalidPayloadException(`Provided snapshot's directus version ${snapshot.directus} does not match the current instance's version ${currentDirectusVersion}. You can bypass this check by passing the "force" query parameter.`);
+        throw new InvalidPayloadError({
+            reason: `Provided snapshot's directus version ${snapshot.directus} does not match the current instance's version ${currentDirectusVersion}. You can bypass this check by passing the "force" query parameter`,
+        });
     }
     if (!snapshot.vendor) {
-        throw new InvalidPayloadException('Provided snapshot does not contain the "vendor" property. You can bypass this check by passing the "force" query parameter.');
+        throw new InvalidPayloadError({
+            reason: 'Provided snapshot does not contain the "vendor" property. You can bypass this check by passing the "force" query parameter',
+        });
     }
     const currentVendor = getDatabaseClient();
     if (snapshot.vendor !== currentVendor) {
-        throw new InvalidPayloadException(`Provided snapshot's vendor ${snapshot.vendor} does not match the current instance's vendor ${currentVendor}. You can bypass this check by passing the "force" query parameter.`);
+        throw new InvalidPayloadError({
+            reason: `Provided snapshot's vendor ${snapshot.vendor} does not match the current instance's vendor ${currentVendor}. You can bypass this check by passing the "force" query parameter`,
+        });
     }
 }

package/dist/websocket/authenticate.js

@@ -1,11 +1,9 @@
 import { DEFAULT_AUTH_PROVIDER } from '../constants.js';
-import getDatabase from '../database/index.js';
-import { InvalidCredentialsException } from '../exceptions/index.js';
 import { AuthenticationService } from '../services/index.js';
-import { getAccountabilityForRole } from '../utils/get-accountability-for-role.js';
 import { getAccountabilityForToken } from '../utils/get-accountability-for-token.js';
+import { getPermissions } from '../utils/get-permissions.js';
 import { getSchema } from '../utils/get-schema.js';
-import { WebSocketException } from './exceptions.js';
+import { WebSocketError } from './errors.js';
 import { getExpiresAtForToken } from './utils/get-expires-at-for-token.js';
 export async function authenticateConnection(message) {
     let access_token, refresh_token;
@@ -32,20 +30,19 @@ export async function authenticateConnection(message) {
         return { accountability, expires_at, refresh_token };
     }
     catch (error) {
-        if (error instanceof InvalidCredentialsException && error.message === 'Token expired.') {
-            throw new WebSocketException('auth', 'TOKEN_EXPIRED', 'Token expired.', message['uid']);
-        }
-        throw new WebSocketException('auth', 'AUTH_FAILED', 'Authentication failed.', message['uid']);
+        throw new WebSocketError('auth', 'AUTH_FAILED', 'Authentication failed.', message['uid']);
     }
 }
 export async function refreshAccountability(accountability) {
-    const result = await getAccountabilityForRole(accountability?.role || null, {
-        accountability: accountability || null,
-        schema: await getSchema(),
-        database: getDatabase(),
-    });
-    result.user = accountability?.user || null;
-    return result;
+    accountability = accountability ?? {
+        role: null,
+        user: null,
+        admin: false,
+        app: false,
+    };
+    const schema = await getSchema();
+    const permissions = await getPermissions(accountability, schema);
+    return { ...accountability, permissions };
 }
 export function authenticationSuccess(uid, refresh_token) {
     const message = {