@wbce-d9/api 9.26.3

package/dist/cli/utils/create-env/index.js

@@ -0,0 +1,41 @@
+import fs from 'fs';
+import { Liquid } from 'liquidjs';
+import { dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import path from 'path';
+import { promisify } from 'util';
+import { v4 as uuid } from 'uuid';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const readFile = promisify(fs.readFile);
+const writeFile = promisify(fs.writeFile);
+const fchmod = promisify(fs.fchmod);
+const open = promisify(fs.open);
+const liquidEngine = new Liquid({
+    extname: '.liquid',
+});
+export default async function createEnv(client, credentials, directory) {
+    const { nanoid } = await import('nanoid');
+    const config = {
+        security: {
+            KEY: uuid(),
+            SECRET: nanoid(32),
+        },
+        database: {
+            DB_CLIENT: client,
+        },
+    };
+    for (const [key, value] of Object.entries(credentials)) {
+        config['database'][`DB_${key.toUpperCase()}`] = value;
+    }
+    const configAsStrings = {};
+    for (const [key, value] of Object.entries(config)) {
+        configAsStrings[key] = '';
+        for (const [envKey, envValue] of Object.entries(value)) {
+            configAsStrings[key] += `${envKey}="${envValue}"\n`;
+        }
+    }
+    const templateString = await readFile(path.join(__dirname, 'env-stub.liquid'), 'utf8');
+    const text = await liquidEngine.parseAndRender(templateString, configAsStrings);
+    await writeFile(path.join(directory, '.env'), text);
+    await fchmod(await open(path.join(directory, '.env'), 'r+'), 0o640);
+}

package/dist/cli/utils/defaults.d.ts

@@ -0,0 +1,11 @@
+export declare const defaultAdminRole: {
+    name: string;
+    icon: string;
+    admin_access: boolean;
+    description: string;
+};
+export declare const defaultAdminUser: {
+    status: string;
+    first_name: string;
+    last_name: string;
+};

package/dist/cli/utils/defaults.js

@@ -0,0 +1,11 @@
+export const defaultAdminRole = {
+    name: 'Administrator',
+    icon: 'verified',
+    admin_access: true,
+    description: '$t:admin_description',
+};
+export const defaultAdminUser = {
+    status: 'active',
+    first_name: 'Admin',
+    last_name: 'User',
+};

package/dist/cli/utils/drivers.d.ts

@@ -0,0 +1,3 @@
+import type { Driver } from '../../types/index.js';
+export declare const drivers: Record<Driver, string>;
+export declare function getDriverForClient(client: string): Driver | null;

package/dist/cli/utils/drivers.js

@@ -0,0 +1,15 @@
+export const drivers = {
+    pg: 'PostgreSQL / Redshift',
+    cockroachdb: 'CockroachDB (Beta)',
+    mysql: 'MySQL / MariaDB / Aurora',
+    sqlite3: 'SQLite',
+    mssql: 'Microsoft SQL Server',
+    oracledb: 'Oracle Database',
+};
+export function getDriverForClient(client) {
+    for (const [key, value] of Object.entries(drivers)) {
+        if (value === client)
+            return key;
+    }
+    return null;
+}

package/dist/constants.d.ts

@@ -0,0 +1,17 @@
+import type { CookieOptions } from 'express';
+import type { TransformationParams } from './types/index.js';
+export declare const SYSTEM_ASSET_ALLOW_LIST: TransformationParams[];
+export declare const ASSET_TRANSFORM_QUERY_KEYS: Array<keyof TransformationParams>;
+export declare const FILTER_VARIABLES: string[];
+export declare const ALIAS_TYPES: string[];
+export declare const DEFAULT_AUTH_PROVIDER = "default";
+export declare const COLUMN_TRANSFORMS: string[];
+export declare const GENERATE_SPECIAL: string[];
+export declare const UUID_REGEX = "[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}";
+export declare const COOKIE_OPTIONS: CookieOptions;
+export declare const OAS_REQUIRED_SCHEMAS: string[];
+/** Formats from which transformation is supported */
+export declare const SUPPORTED_IMAGE_TRANSFORM_FORMATS: string[];
+/** Formats where metadata extraction is supported */
+export declare const SUPPORTED_IMAGE_METADATA_FORMATS: string[];
+export declare const REDACT_TEXT = "--redact--";

package/dist/constants.js

@@ -0,0 +1,70 @@
+import env from './env.js';
+import { getMilliseconds } from './utils/get-milliseconds.js';
+export const SYSTEM_ASSET_ALLOW_LIST = [
+    {
+        key: 'system-small-cover',
+        format: 'auto',
+        transforms: [['resize', { width: 64, height: 64, fit: 'cover' }]],
+    },
+    {
+        key: 'system-small-contain',
+        format: 'auto',
+        transforms: [['resize', { width: 64, fit: 'contain' }]],
+    },
+    {
+        key: 'system-medium-cover',
+        format: 'auto',
+        transforms: [['resize', { width: 300, height: 300, fit: 'cover' }]],
+    },
+    {
+        key: 'system-medium-contain',
+        format: 'auto',
+        transforms: [['resize', { width: 300, fit: 'contain' }]],
+    },
+    {
+        key: 'system-large-cover',
+        format: 'auto',
+        transforms: [['resize', { width: 800, height: 800, fit: 'cover' }]],
+    },
+    {
+        key: 'system-large-contain',
+        format: 'auto',
+        transforms: [['resize', { width: 800, fit: 'contain' }]],
+    },
+];
+export const ASSET_TRANSFORM_QUERY_KEYS = [
+    'key',
+    'transforms',
+    'width',
+    'height',
+    'format',
+    'fit',
+    'quality',
+    'withoutEnlargement',
+];
+export const FILTER_VARIABLES = ['$NOW', '$CURRENT_USER', '$CURRENT_ROLE'];
+export const ALIAS_TYPES = ['alias', 'o2m', 'm2m', 'm2a', 'o2a', 'files', 'translations'];
+export const DEFAULT_AUTH_PROVIDER = 'default';
+export const COLUMN_TRANSFORMS = ['year', 'month', 'day', 'weekday', 'hour', 'minute', 'second'];
+export const GENERATE_SPECIAL = ['uuid', 'date-created', 'role-created', 'user-created'];
+export const UUID_REGEX = '[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}';
+export const COOKIE_OPTIONS = {
+    httpOnly: true,
+    domain: env['REFRESH_TOKEN_COOKIE_DOMAIN'],
+    maxAge: getMilliseconds(env['REFRESH_TOKEN_TTL']),
+    secure: env['REFRESH_TOKEN_COOKIE_SECURE'] ?? false,
+    sameSite: env['REFRESH_TOKEN_COOKIE_SAME_SITE'] || 'strict',
+};
+export const OAS_REQUIRED_SCHEMAS = ['Diff', 'Schema', 'Query', 'x-metadata'];
+/** Formats from which transformation is supported */
+export const SUPPORTED_IMAGE_TRANSFORM_FORMATS = ['image/jpeg', 'image/png', 'image/webp', 'image/tiff', 'image/avif'];
+/** Formats where metadata extraction is supported */
+export const SUPPORTED_IMAGE_METADATA_FORMATS = [
+    'image/jpeg',
+    'image/png',
+    'image/webp',
+    'image/gif',
+    'image/tiff',
+    'image/avif',
+];
+export const REDACT_TEXT = '--redact--';

package/dist/controllers/activity.d.ts

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

package/dist/controllers/activity.js

@@ -0,0 +1,131 @@
+import { Action } from '@wbce-d9/constants';
+import express from 'express';
+import Joi from 'joi';
+import { ForbiddenException, InvalidPayloadException } from '../exceptions/index.js';
+import { respond } from '../middleware/respond.js';
+import useCollection from '../middleware/use-collection.js';
+import { validateBatch } from '../middleware/validate-batch.js';
+import { ActivityService } from '../services/activity.js';
+import { MetaService } from '../services/meta.js';
+import asyncHandler from '../utils/async-handler.js';
+import { getIPFromReq } from '../utils/get-ip-from-req.js';
+const router = express.Router();
+router.use(useCollection('directus_activity'));
+const readHandler = asyncHandler(async (req, res, next) => {
+    const service = new ActivityService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    const metaService = new MetaService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    let result;
+    if (req.singleton) {
+        result = await service.readSingleton(req.sanitizedQuery);
+    }
+    else if (req.body.keys) {
+        result = await service.readMany(req.body.keys, req.sanitizedQuery);
+    }
+    else {
+        result = await service.readByQuery(req.sanitizedQuery);
+    }
+    const meta = await metaService.getMetaForQuery('directus_activity', req.sanitizedQuery);
+    res.locals['payload'] = {
+        data: result,
+        meta,
+    };
+    return next();
+});
+router.search('/', validateBatch('read'), readHandler, respond);
+router.get('/', readHandler, respond);
+router.get('/:pk', asyncHandler(async (req, res, next) => {
+    const service = new ActivityService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    const record = await service.readOne(req.params['pk'], req.sanitizedQuery);
+    res.locals['payload'] = {
+        data: record || null,
+    };
+    return next();
+}), respond);
+const createCommentSchema = Joi.object({
+    comment: Joi.string().required(),
+    collection: Joi.string().required(),
+    item: [Joi.number().required(), Joi.string().required()],
+});
+router.post('/comment', asyncHandler(async (req, res, next) => {
+    const service = new ActivityService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    const { error } = createCommentSchema.validate(req.body);
+    if (error) {
+        throw new InvalidPayloadException(error.message);
+    }
+    const primaryKey = await service.createOne({
+        ...req.body,
+        action: Action.COMMENT,
+        user: req.accountability?.user,
+        ip: getIPFromReq(req),
+        user_agent: req.get('user-agent'),
+        origin: req.get('origin'),
+    });
+    try {
+        const record = await service.readOne(primaryKey, req.sanitizedQuery);
+        res.locals['payload'] = {
+            data: record || null,
+        };
+    }
+    catch (error) {
+        if (error instanceof ForbiddenException) {
+            return next();
+        }
+        throw error;
+    }
+    return next();
+}), respond);
+const updateCommentSchema = Joi.object({
+    comment: Joi.string().required(),
+});
+router.patch('/comment/:pk', asyncHandler(async (req, res, next) => {
+    const service = new ActivityService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    const { error } = updateCommentSchema.validate(req.body);
+    if (error) {
+        throw new InvalidPayloadException(error.message);
+    }
+    const primaryKey = await service.updateOne(req.params['pk'], req.body);
+    try {
+        const record = await service.readOne(primaryKey, req.sanitizedQuery);
+        res.locals['payload'] = {
+            data: record || null,
+        };
+    }
+    catch (error) {
+        if (error instanceof ForbiddenException) {
+            return next();
+        }
+        throw error;
+    }
+    return next();
+}), respond);
+router.delete('/comment/:pk', asyncHandler(async (req, _res, next) => {
+    const service = new ActivityService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    const adminService = new ActivityService({
+        schema: req.schema,
+    });
+    const item = await adminService.readOne(req.params['pk'], { fields: ['action'] });
+    if (!item || item['action'] !== Action.COMMENT) {
+        throw new ForbiddenException();
+    }
+    await service.deleteOne(req.params['pk']);
+    return next();
+}), respond);
+export default router;

package/dist/controllers/assets.d.ts

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

package/dist/controllers/assets.js

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

package/dist/controllers/auth.d.ts

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