@directus/api 9.25.0

package/dist/utils/get-permissions.js

@@ -0,0 +1,151 @@
+import { deepMap, parseFilter, parseJSON, parsePreset } from '@directus/utils';
+import { cloneDeep } from 'lodash-es';
+import hash from 'object-hash';
+import { getCache, getCacheValue, getSystemCache, setCacheValue, setSystemCache } from '../cache.js';
+import getDatabase from '../database/index.js';
+import { appAccessMinimalPermissions } from '../database/system-data/app-access-permissions/index.js';
+import env from '../env.js';
+import logger from '../logger.js';
+import { RolesService } from '../services/roles.js';
+import { UsersService } from '../services/users.js';
+import { mergePermissions } from '../utils/merge-permissions.js';
+import { mergePermissionsForShare } from './merge-permissions-for-share.js';
+export async function getPermissions(accountability, schema) {
+    const database = getDatabase();
+    const { cache } = getCache();
+    let permissions = [];
+    const { user, role, app, admin, share_scope } = accountability;
+    const cacheKey = `permissions-${hash({ user, role, app, admin, share_scope })}`;
+    if (cache && env['CACHE_PERMISSIONS'] !== false) {
+        let cachedPermissions;
+        try {
+            cachedPermissions = await getSystemCache(cacheKey);
+        }
+        catch (err) {
+            logger.warn(err, `[cache] Couldn't read key ${cacheKey}. ${err.message}`);
+        }
+        if (cachedPermissions) {
+            if (!cachedPermissions['containDynamicData']) {
+                return processPermissions(accountability, cachedPermissions['permissions'], {});
+            }
+            const cachedFilterContext = await getCacheValue(cache, `filterContext-${hash({ user, role, permissions: cachedPermissions['permissions'] })}`);
+            if (cachedFilterContext) {
+                return processPermissions(accountability, cachedPermissions['permissions'], cachedFilterContext);
+            }
+            else {
+                const { permissions: parsedPermissions, requiredPermissionData, containDynamicData, } = parsePermissions(cachedPermissions['permissions']);
+                permissions = parsedPermissions;
+                const filterContext = containDynamicData
+                    ? await getFilterContext(schema, accountability, requiredPermissionData)
+                    : {};
+                if (containDynamicData && env['CACHE_ENABLED'] !== false) {
+                    await setCacheValue(cache, `filterContext-${hash({ user, role, permissions })}`, filterContext);
+                }
+                return processPermissions(accountability, permissions, filterContext);
+            }
+        }
+    }
+    if (accountability.admin !== true) {
+        const query = database.select('*').from('directus_permissions');
+        if (accountability.role) {
+            query.where({ role: accountability.role });
+        }
+        else {
+            query.whereNull('role');
+        }
+        const permissionsForRole = await query;
+        const { permissions: parsedPermissions, requiredPermissionData, containDynamicData, } = parsePermissions(permissionsForRole);
+        permissions = parsedPermissions;
+        if (accountability.app === true) {
+            permissions = mergePermissions('or', permissions, appAccessMinimalPermissions.map((perm) => ({ ...perm, role: accountability.role })));
+        }
+        if (accountability.share_scope) {
+            permissions = mergePermissionsForShare(permissions, accountability, schema);
+        }
+        const filterContext = containDynamicData
+            ? await getFilterContext(schema, accountability, requiredPermissionData)
+            : {};
+        if (cache && env['CACHE_PERMISSIONS'] !== false) {
+            await setSystemCache(cacheKey, { permissions, containDynamicData });
+            if (containDynamicData && env['CACHE_ENABLED'] !== false) {
+                await setCacheValue(cache, `filterContext-${hash({ user, role, permissions })}`, filterContext);
+            }
+        }
+        return processPermissions(accountability, permissions, filterContext);
+    }
+    return permissions;
+}
+function parsePermissions(permissions) {
+    const requiredPermissionData = {
+        $CURRENT_USER: [],
+        $CURRENT_ROLE: [],
+    };
+    let containDynamicData = false;
+    permissions = permissions.map((permissionRaw) => {
+        const permission = cloneDeep(permissionRaw);
+        if (permission.permissions && typeof permission.permissions === 'string') {
+            permission.permissions = parseJSON(permission.permissions);
+        }
+        else if (permission.permissions === null) {
+            permission.permissions = {};
+        }
+        if (permission.validation && typeof permission.validation === 'string') {
+            permission.validation = parseJSON(permission.validation);
+        }
+        else if (permission.validation === null) {
+            permission.validation = {};
+        }
+        if (permission.presets && typeof permission.presets === 'string') {
+            permission.presets = parseJSON(permission.presets);
+        }
+        else if (permission.presets === null) {
+            permission.presets = {};
+        }
+        if (permission.fields && typeof permission.fields === 'string') {
+            permission.fields = permission.fields.split(',');
+        }
+        else if (permission.fields === null) {
+            permission.fields = [];
+        }
+        const extractPermissionData = (val) => {
+            if (typeof val === 'string' && val.startsWith('$CURRENT_USER.')) {
+                requiredPermissionData.$CURRENT_USER.push(val.replace('$CURRENT_USER.', ''));
+                containDynamicData = true;
+            }
+            if (typeof val === 'string' && val.startsWith('$CURRENT_ROLE.')) {
+                requiredPermissionData.$CURRENT_ROLE.push(val.replace('$CURRENT_ROLE.', ''));
+                containDynamicData = true;
+            }
+            return val;
+        };
+        deepMap(permission.permissions, extractPermissionData);
+        deepMap(permission.validation, extractPermissionData);
+        deepMap(permission.presets, extractPermissionData);
+        return permission;
+    });
+    return { permissions, requiredPermissionData, containDynamicData };
+}
+async function getFilterContext(schema, accountability, requiredPermissionData) {
+    const usersService = new UsersService({ schema });
+    const rolesService = new RolesService({ schema });
+    const filterContext = {};
+    if (accountability.user && requiredPermissionData.$CURRENT_USER.length > 0) {
+        filterContext['$CURRENT_USER'] = await usersService.readOne(accountability.user, {
+            fields: requiredPermissionData.$CURRENT_USER,
+        });
+    }
+    if (accountability.role && requiredPermissionData.$CURRENT_ROLE.length > 0) {
+        filterContext['$CURRENT_ROLE'] = await rolesService.readOne(accountability.role, {
+            fields: requiredPermissionData.$CURRENT_ROLE,
+        });
+    }
+    return filterContext;
+}
+function processPermissions(accountability, permissions, filterContext) {
+    return permissions.map((permission) => {
+        permission.permissions = parseFilter(permission.permissions, accountability, filterContext);
+        permission.validation = parseFilter(permission.validation, accountability, filterContext);
+        permission.presets = parsePreset(permission.presets, accountability, filterContext);
+        return permission;
+    });
+}

package/dist/utils/get-relation-info.d.ts

@@ -0,0 +1,7 @@
+import type { Relation } from '@directus/types';
+type RelationInfo = {
+    relation: Relation | null;
+    relationType: string | null;
+};
+export declare function getRelationInfo(relations: Relation[], collection: string, field: string): RelationInfo;
+export {};

package/dist/utils/get-relation-info.js

@@ -0,0 +1,45 @@
+import { getRelationType } from './get-relation-type.js';
+function checkImplicitRelation(field) {
+    if (field.startsWith('$FOLLOW(') && field.endsWith(')')) {
+        return field.slice(8, -1).split(',');
+    }
+    return null;
+}
+export function getRelationInfo(relations, collection, field) {
+    if (field.startsWith('$FOLLOW') && field.length > 500) {
+        throw new Error(`Implicit $FOLLOW statement is too big to parse. Got: "${field.substring(500)}..."`);
+    }
+    const implicitRelation = checkImplicitRelation(field);
+    if (implicitRelation) {
+        if (implicitRelation[2] === undefined) {
+            const [m2oCollection, m2oField] = implicitRelation;
+            const relation = {
+                collection: m2oCollection.trim(),
+                field: m2oField.trim(),
+                related_collection: collection,
+                schema: null,
+                meta: null,
+            };
+            return { relation, relationType: 'o2m' };
+        }
+        else {
+            const [a2oCollection, a2oItemField, a2oCollectionField] = implicitRelation;
+            const relation = {
+                collection: a2oCollection.trim(),
+                field: a2oItemField.trim(),
+                related_collection: collection,
+                schema: null,
+                meta: {
+                    one_collection_field: a2oCollectionField.trim(),
+                },
+            };
+            return { relation, relationType: 'o2a' };
+        }
+    }
+    const relation = relations.find((relation) => {
+        return ((relation.collection === collection && relation.field === field) ||
+            (relation.related_collection === collection && relation.meta?.one_field === field));
+    }) ?? null;
+    const relationType = relation ? getRelationType({ relation, collection, field }) : null;
+    return { relation, relationType };
+}

package/dist/utils/get-relation-info.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/get-relation-type.d.ts

@@ -0,0 +1,6 @@
+import type { Relation } from '@directus/types';
+export declare function getRelationType(getRelationOptions: {
+    relation?: Relation | null;
+    collection: string | null;
+    field: string;
+}): 'm2o' | 'o2m' | 'a2o' | null;

package/dist/utils/get-relation-type.js

@@ -0,0 +1,18 @@
+export function getRelationType(getRelationOptions) {
+    const { relation, collection, field } = getRelationOptions;
+    if (!relation)
+        return null;
+    if (relation.collection === collection &&
+        relation.field === field &&
+        relation.meta?.one_collection_field &&
+        relation.meta?.one_allowed_collections) {
+        return 'a2o';
+    }
+    if (relation.collection === collection && relation.field === field) {
+        return 'm2o';
+    }
+    if (relation.related_collection === collection && relation.meta?.one_field === field) {
+        return 'o2m';
+    }
+    return null;
+}

package/dist/utils/get-relation-type.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,10 @@
+import type { SchemaOverview } from '@directus/types';
+import type { Knex } from 'knex';
+export declare function getSchema(options?: {
+    database?: Knex;
+    /**
+     * To bypass any cached schema if bypassCache is enabled.
+     * Used to ensure schema snapshot/apply is not using outdated schema
+     */
+    bypassCache?: boolean;
+}): Promise<SchemaOverview>;

package/dist/utils/get-schema.js

@@ -0,0 +1,131 @@
+import { createInspector } from '@directus/schema';
+import { parseJSON, toArray } from '@directus/utils';
+import { mapValues } from 'lodash-es';
+import { getSchemaCache, setSchemaCache } from '../cache.js';
+import { ALIAS_TYPES } from '../constants.js';
+import getDatabase from '../database/index.js';
+import { systemCollectionRows } from '../database/system-data/collections/index.js';
+import { systemFieldRows } from '../database/system-data/fields/index.js';
+import env from '../env.js';
+import logger from '../logger.js';
+import { RelationsService } from '../services/relations.js';
+import getDefaultValue from './get-default-value.js';
+import getLocalType from './get-local-type.js';
+export async function getSchema(options) {
+    const database = options?.database || getDatabase();
+    const schemaInspector = createInspector(database);
+    let result;
+    if (!options?.bypassCache && env['CACHE_SCHEMA'] !== false) {
+        let cachedSchema;
+        try {
+            cachedSchema = await getSchemaCache();
+        }
+        catch (err) {
+            logger.warn(err, `[schema-cache] Couldn't retrieve cache. ${err}`);
+        }
+        if (cachedSchema) {
+            result = cachedSchema;
+        }
+        else {
+            result = await getDatabaseSchema(database, schemaInspector);
+            try {
+                await setSchemaCache(result);
+            }
+            catch (err) {
+                logger.warn(err, `[schema-cache] Couldn't save cache. ${err}`);
+            }
+        }
+    }
+    else {
+        result = await getDatabaseSchema(database, schemaInspector);
+    }
+    return result;
+}
+async function getDatabaseSchema(database, schemaInspector) {
+    const result = {
+        collections: {},
+        relations: [],
+    };
+    const schemaOverview = await schemaInspector.overview();
+    const collections = [
+        ...(await database
+            .select('collection', 'singleton', 'note', 'sort_field', 'accountability')
+            .from('directus_collections')),
+        ...systemCollectionRows,
+    ];
+    for (const [collection, info] of Object.entries(schemaOverview)) {
+        if (toArray(env['DB_EXCLUDE_TABLES']).includes(collection)) {
+            logger.trace(`Collection "${collection}" is configured to be excluded and will be ignored`);
+            continue;
+        }
+        if (!info.primary) {
+            logger.warn(`Collection "${collection}" doesn't have a primary key column and will be ignored`);
+            continue;
+        }
+        if (collection.includes(' ')) {
+            logger.warn(`Collection "${collection}" has a space in the name and will be ignored`);
+            continue;
+        }
+        const collectionMeta = collections.find((collectionMeta) => collectionMeta.collection === collection);
+        result.collections[collection] = {
+            collection,
+            primary: info.primary,
+            singleton: collectionMeta?.singleton === true || collectionMeta?.singleton === 'true' || collectionMeta?.singleton === 1,
+            note: collectionMeta?.note || null,
+            sortField: collectionMeta?.sort_field || null,
+            accountability: collectionMeta ? collectionMeta.accountability : 'all',
+            fields: mapValues(schemaOverview[collection]?.columns, (column) => {
+                return {
+                    field: column.column_name,
+                    defaultValue: getDefaultValue(column) ?? null,
+                    nullable: column.is_nullable ?? true,
+                    generated: column.is_generated ?? false,
+                    type: getLocalType(column),
+                    dbType: column.data_type,
+                    precision: column.numeric_precision || null,
+                    scale: column.numeric_scale || null,
+                    special: [],
+                    note: null,
+                    validation: null,
+                    alias: false,
+                };
+            }),
+        };
+    }
+    const fields = [
+        ...(await database
+            .select('id', 'collection', 'field', 'special', 'note', 'validation')
+            .from('directus_fields')),
+        ...systemFieldRows,
+    ].filter((field) => (field.special ? toArray(field.special) : []).includes('no-data') === false);
+    for (const field of fields) {
+        if (!result.collections[field.collection])
+            continue;
+        const existing = result.collections[field.collection]?.fields[field.field];
+        const column = schemaOverview[field.collection]?.columns[field.field];
+        const special = field.special ? toArray(field.special) : [];
+        if (ALIAS_TYPES.some((type) => special.includes(type)) === false && !existing)
+            continue;
+        const type = (existing && getLocalType(column, { special })) || 'alias';
+        let validation = field.validation ?? null;
+        if (validation && typeof validation === 'string')
+            validation = parseJSON(validation);
+        result.collections[field.collection].fields[field.field] = {
+            field: field.field,
+            defaultValue: existing?.defaultValue ?? null,
+            nullable: existing?.nullable ?? true,
+            generated: existing?.generated ?? false,
+            type: type,
+            dbType: existing?.dbType || null,
+            precision: existing?.precision || null,
+            scale: existing?.scale || null,
+            special: special,
+            note: field.note,
+            alias: existing?.alias ?? true,
+            validation: validation ?? null,
+        };
+    }
+    const relationsService = new RelationsService({ knex: database, schema: result });
+    result.relations = await relationsService.readAll();
+    return result;
+}

package/dist/utils/get-snapshot-diff.d.ts

@@ -0,0 +1,2 @@
+import { Snapshot, SnapshotDiff } from '../types/index.js';
+export declare function getSnapshotDiff(current: Snapshot, after: Snapshot): SnapshotDiff;

package/dist/utils/get-snapshot-diff.js

@@ -0,0 +1,78 @@
+import deepDiff from 'deep-diff';
+import { orderBy } from 'lodash-es';
+import { DiffKind } from '../types/index.js';
+import { sanitizeCollection, sanitizeField, sanitizeRelation } from './sanitize-schema.js';
+export function getSnapshotDiff(current, after) {
+    const diffedSnapshot = {
+        collections: orderBy([
+            ...current.collections.map((currentCollection) => {
+                const afterCollection = after.collections.find((afterCollection) => afterCollection.collection === currentCollection.collection);
+                return {
+                    collection: currentCollection.collection,
+                    diff: deepDiff.diff(sanitizeCollection(currentCollection), sanitizeCollection(afterCollection)),
+                };
+            }),
+            ...after.collections
+                .filter((afterCollection) => {
+                const currentCollection = current.collections.find((currentCollection) => currentCollection.collection === afterCollection.collection);
+                return !!currentCollection === false;
+            })
+                .map((afterCollection) => ({
+                collection: afterCollection.collection,
+                diff: deepDiff.diff(undefined, sanitizeCollection(afterCollection)),
+            })),
+        ].filter((obj) => Array.isArray(obj.diff)), 'collection'),
+        fields: orderBy([
+            ...current.fields.map((currentField) => {
+                const afterField = after.fields.find((afterField) => afterField.collection === currentField.collection && afterField.field === currentField.field);
+                const isAutoIncrementPrimaryKey = !!currentField.schema?.is_primary_key && !!currentField.schema?.has_auto_increment;
+                return {
+                    collection: currentField.collection,
+                    field: currentField.field,
+                    diff: deepDiff.diff(sanitizeField(currentField, isAutoIncrementPrimaryKey), sanitizeField(afterField, isAutoIncrementPrimaryKey)),
+                };
+            }),
+            ...after.fields
+                .filter((afterField) => {
+                const currentField = current.fields.find((currentField) => currentField.collection === afterField.collection && afterField.field === currentField.field);
+                return !!currentField === false;
+            })
+                .map((afterField) => ({
+                collection: afterField.collection,
+                field: afterField.field,
+                diff: deepDiff.diff(undefined, sanitizeField(afterField)),
+            })),
+        ].filter((obj) => Array.isArray(obj.diff)), ['collection']),
+        relations: orderBy([
+            ...current.relations.map((currentRelation) => {
+                const afterRelation = after.relations.find((afterRelation) => afterRelation.collection === currentRelation.collection && afterRelation.field === currentRelation.field);
+                return {
+                    collection: currentRelation.collection,
+                    field: currentRelation.field,
+                    related_collection: currentRelation.related_collection,
+                    diff: deepDiff.diff(sanitizeRelation(currentRelation), sanitizeRelation(afterRelation)),
+                };
+            }),
+            ...after.relations
+                .filter((afterRelation) => {
+                const currentRelation = current.relations.find((currentRelation) => currentRelation.collection === afterRelation.collection && afterRelation.field === currentRelation.field);
+                return !!currentRelation === false;
+            })
+                .map((afterRelation) => ({
+                collection: afterRelation.collection,
+                field: afterRelation.field,
+                related_collection: afterRelation.related_collection,
+                diff: deepDiff.diff(undefined, sanitizeRelation(afterRelation)),
+            })),
+        ].filter((obj) => Array.isArray(obj.diff)), ['collection']),
+    };
+    /**
+     * When you delete a collection, we don't have to individually drop all the fields/relations as well
+     */
+    const deletedCollections = diffedSnapshot.collections
+        .filter((collection) => collection.diff?.[0]?.kind === DiffKind.DELETE)
+        .map(({ collection }) => collection);
+    diffedSnapshot.fields = diffedSnapshot.fields.filter((field) => deletedCollections.includes(field.collection) === false);
+    diffedSnapshot.relations = diffedSnapshot.relations.filter((relation) => deletedCollections.includes(relation.collection) === false);
+    return diffedSnapshot;
+}

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

@@ -0,0 +1,7 @@
+import type { SchemaOverview } from '@directus/types';
+import type { Knex } from 'knex';
+import type { Snapshot } from '../types/index.js';
+export declare function getSnapshot(options?: {
+    database?: Knex;
+    schema?: SchemaOverview;
+}): Promise<Snapshot>;

package/dist/utils/get-snapshot.js

@@ -0,0 +1,55 @@
+import { fromPairs, isArray, isPlainObject, mapValues, omit, sortBy, toPairs } from 'lodash-es';
+import getDatabase, { getDatabaseClient } from '../database/index.js';
+import { CollectionsService } from '../services/collections.js';
+import { FieldsService } from '../services/fields.js';
+import { RelationsService } from '../services/relations.js';
+import { getSchema } from './get-schema.js';
+import { version } from './package.js';
+import { sanitizeCollection, sanitizeField, sanitizeRelation } from './sanitize-schema.js';
+export async function getSnapshot(options) {
+    const database = options?.database ?? getDatabase();
+    const vendor = getDatabaseClient(database);
+    const schema = options?.schema ?? (await getSchema({ database, bypassCache: true }));
+    const collectionsService = new CollectionsService({ knex: database, schema });
+    const fieldsService = new FieldsService({ knex: database, schema });
+    const relationsService = new RelationsService({ knex: database, schema });
+    const [collectionsRaw, fieldsRaw, relationsRaw] = await Promise.all([
+        collectionsService.readByQuery(),
+        fieldsService.readAll(),
+        relationsService.readAll(),
+    ]);
+    const collectionsFiltered = collectionsRaw.filter((item) => excludeSystem(item));
+    const fieldsFiltered = fieldsRaw.filter((item) => excludeSystem(item)).map(omitID);
+    const relationsFiltered = relationsRaw.filter((item) => excludeSystem(item)).map(omitID);
+    const collectionsSorted = sortBy(mapValues(collectionsFiltered, sortDeep), ['collection']);
+    const fieldsSorted = sortBy(mapValues(fieldsFiltered, sortDeep), ['collection', 'field']);
+    const relationsSorted = sortBy(mapValues(relationsFiltered, sortDeep), ['collection', 'field']);
+    return {
+        version: 1,
+        directus: version,
+        vendor,
+        collections: collectionsSorted.map((collection) => sanitizeCollection(collection)),
+        fields: fieldsSorted.map((field) => sanitizeField(field)),
+        relations: relationsSorted.map((relation) => sanitizeRelation(relation)),
+    };
+}
+function excludeSystem(item) {
+    if (item?.meta?.system === true)
+        return false;
+    return true;
+}
+function omitID(item) {
+    return omit(item, 'meta.id');
+}
+function sortDeep(raw) {
+    if (isPlainObject(raw)) {
+        const mapped = mapValues(raw, sortDeep);
+        const pairs = toPairs(mapped);
+        const sorted = sortBy(pairs);
+        return fromPairs(sorted);
+    }
+    if (isArray(raw)) {
+        return sortBy(raw);
+    }
+    return raw;
+}

package/dist/utils/get-string-byte-size.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Returns the byte size for a given input string
+ */
+export declare function stringByteSize(string: string): number;

package/dist/utils/get-string-byte-size.js

@@ -0,0 +1,6 @@
+/**
+ * Returns the byte size for a given input string
+ */
+export function stringByteSize(string) {
+    return Buffer.byteLength(string, 'utf-8');
+}

package/dist/utils/get-string-byte-size.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/get-versioned-hash.d.ts

@@ -0,0 +1 @@
+export declare function getVersionedHash(item: Record<string, any>): string;

package/dist/utils/get-versioned-hash.js

@@ -0,0 +1,5 @@
+import hash from 'object-hash';
+import { version } from './package.js';
+export function getVersionedHash(item) {
+    return hash({ item, version });
+}

package/dist/utils/get-versioned-hash.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/is-directus-jwt.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Check if a given string conforms to the structure of a JWT
+ * and whether it is issued by Directus.
+ */
+export default function isDirectusJWT(string: string): boolean;

package/dist/utils/is-directus-jwt.js

@@ -0,0 +1,16 @@
+import jwt from 'jsonwebtoken';
+/**
+ * Check if a given string conforms to the structure of a JWT
+ * and whether it is issued by Directus.
+ */
+export default function isDirectusJWT(string) {
+    try {
+        const payload = jwt.decode(string, { json: true });
+        if (payload?.iss !== 'directus')
+            return false;
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/utils/is-directus-jwt.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/is-url-allowed.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Check if url matches allow list either exactly or by domain+path
+ */
+export default function isUrlAllowed(url: string, allowList: string | string[]): boolean;

package/dist/utils/is-url-allowed.js

@@ -0,0 +1,30 @@
+import { toArray } from '@directus/utils';
+import logger from '../logger.js';
+import { URL } from 'url';
+/**
+ * Check if url matches allow list either exactly or by domain+path
+ */
+export default function isUrlAllowed(url, allowList) {
+    const urlAllowList = toArray(allowList);
+    if (urlAllowList.includes(url))
+        return true;
+    const parsedWhitelist = urlAllowList
+        .map((allowedURL) => {
+        try {
+            const { hostname, pathname } = new URL(allowedURL);
+            return hostname + pathname;
+        }
+        catch {
+            logger.warn(`Invalid URL used "${url}"`);
+        }
+        return null;
+    })
+        .filter((f) => f);
+    try {
+        const { hostname, pathname } = new URL(url);
+        return parsedWhitelist.includes(hostname + pathname);
+    }
+    catch {
+        return false;
+    }
+}

package/dist/utils/job-queue.d.ts

@@ -0,0 +1,9 @@
+type Job = () => Promise<void> | void;
+export declare class JobQueue {
+    private running;
+    private jobs;
+    constructor();
+    enqueue(job: Job): void;
+    private run;
+}
+export {};

package/dist/utils/job-queue.js

@@ -0,0 +1,22 @@
+export class JobQueue {
+    running;
+    jobs;
+    constructor() {
+        this.running = false;
+        this.jobs = [];
+    }
+    enqueue(job) {
+        this.jobs.push(job);
+        if (!this.running) {
+            this.run();
+        }
+    }
+    async run() {
+        this.running = true;
+        while (this.jobs.length > 0) {
+            const job = this.jobs.shift();
+            await job();
+        }
+        this.running = false;
+    }
+}