@appsemble/node-utils 0.20.45 → 0.21.0

package/README.md

@@ -1,9 +1,9 @@
-# ![](https://gitlab.com/appsemble/appsemble/-/raw/0.20.45/config/assets/logo.svg) Appsemble Node Utilities
+# ![](https://gitlab.com/appsemble/appsemble/-/raw/0.21.0/config/assets/logo.svg) Appsemble Node Utilities
 
 > NodeJS utilities used by Appsemble internally.
 
 [![npm](https://img.shields.io/npm/v/@appsemble/node-utils)](https://www.npmjs.com/package/@appsemble/node-utils)
-[![GitLab CI](https://gitlab.com/appsemble/appsemble/badges/0.20.45/pipeline.svg)](https://gitlab.com/appsemble/appsemble/-/releases/0.20.45)
+[![GitLab CI](https://gitlab.com/appsemble/appsemble/badges/0.21.0/pipeline.svg)](https://gitlab.com/appsemble/appsemble/-/releases/0.21.0)
 [![Prettier](https://img.shields.io/badge/code_style-prettier-ff69b4.svg)](https://prettier.io)
 
 ## Table of Contents
@@ -26,5 +26,5 @@ compatibility is not guaranteed.
 
 ## License
 
-[LGPL-3.0-only](https://gitlab.com/appsemble/appsemble/-/blob/0.20.45/LICENSE.md) ©
+[LGPL-3.0-only](https://gitlab.com/appsemble/appsemble/-/blob/0.21.0/LICENSE.md) ©
 [Appsemble](https://appsemble.com)

package/app.d.ts

@@ -0,0 +1,17 @@
+import { type App, type UserInfo } from '@appsemble/types';
+import { type RemapperContext } from '@appsemble/utils';
+import { type DefaultContext, type DefaultState, type ParameterizedContext } from 'koa';
+import { type Options } from './server/types.js';
+/**
+ * Get a context for remappers based on an app definition.
+ *
+ * This allows to use remappers with the context of an app on the server.
+ *
+ * @param app The app for which to get the remapper context.
+ * @param language The preferred language for the context.
+ * @param userInfo The OAuth2 compatible user information.
+ * @param options The utility options.
+ * @param context The koa context.
+ * @returns A localized remapper context for the app.
+ */
+export declare function getRemapperContext(app: App, language: string, userInfo: UserInfo, options: Options, context: ParameterizedContext<DefaultState, DefaultContext, any>): Promise<RemapperContext>;

package/app.js

@@ -0,0 +1,49 @@
+import { defaultLocale, has, objectCache } from '@appsemble/utils';
+import { memoize } from '@formatjs/fast-memoize';
+import { IntlMessageFormat } from 'intl-messageformat';
+const getNumberFormat = memoize((locale, opts) => new Intl.NumberFormat(locale, opts));
+const getPluralRules = memoize((locale, opts) => new Intl.PluralRules(locale, opts));
+/**
+ * Get a context for remappers based on an app definition.
+ *
+ * This allows to use remappers with the context of an app on the server.
+ *
+ * @param app The app for which to get the remapper context.
+ * @param language The preferred language for the context.
+ * @param userInfo The OAuth2 compatible user information.
+ * @param options The utility options.
+ * @param context The koa context.
+ * @returns A localized remapper context for the app.
+ */
+export async function getRemapperContext(app, language, userInfo, options, context) {
+    var _a, _b;
+    const { getAppMessages, getAppUrl } = options;
+    const appUrl = String(await getAppUrl({ context, app }));
+    const appMessages = await getAppMessages({
+        app,
+        context,
+        language,
+    });
+    const cache = objectCache((message) => new IntlMessageFormat(message, language, undefined, {
+        formatters: {
+            // @ts-expect-error intl-messageformat types are wrong
+            getNumberFormat,
+            getPluralRules,
+            getDateTimeFormat: memoize((locale, opts) => new Intl.DateTimeFormat(locale, { ...opts, timeZone: userInfo === null || userInfo === void 0 ? void 0 : userInfo.zoneinfo })),
+        },
+    }));
+    return {
+        appId: app.id,
+        appUrl,
+        url: appUrl,
+        getMessage({ defaultMessage, id }) {
+            const msg = appMessages.find(({ messages }) => has(messages.messageIds, id));
+            const message = msg ? msg.messages.messageIds[id] : defaultMessage;
+            return cache(message || `'{${id}}'`);
+        },
+        userInfo,
+        context: {},
+        locale: (_b = (_a = userInfo === null || userInfo === void 0 ? void 0 : userInfo.locale) !== null && _a !== void 0 ? _a : app.definition.defaultLanguage) !== null && _b !== void 0 ? _b : defaultLocale,
+    };
+}
+//# sourceMappingURL=app.js.map

package/csv.d.ts

@@ -0,0 +1,2 @@
+import { type PreValidatePropertyFunction } from 'jsonschema';
+export declare const preProcessCSV: PreValidatePropertyFunction;

package/csv.js

@@ -0,0 +1,55 @@
+export const preProcessCSV = (instance, key, schema, options, ctx) => {
+    // CSV is parsed into an array of flat objects. This means all instances are a direct descendant
+    // of the root array and the path length is 1.
+    if (ctx.path.length !== 1) {
+        return;
+    }
+    const parent = instance;
+    const value = instance[key];
+    switch (schema.type) {
+        case 'null':
+            if (value === 'null') {
+                parent[key] = null;
+            }
+            break;
+        case 'boolean':
+            if (value === 'true') {
+                parent[key] = true;
+            }
+            else if (value === 'false') {
+                parent[key] = false;
+            }
+            break;
+        case 'integer': {
+            const result = Number(value);
+            if (Number.isInteger(result)) {
+                parent[key] = result;
+            }
+            break;
+        }
+        case 'number': {
+            const result = Number(value);
+            if (Number.isFinite(result)) {
+                parent[key] = result;
+            }
+            break;
+        }
+        case 'array': {
+            const result = JSON.parse(value);
+            if (Array.isArray(result)) {
+                parent[key] = result;
+            }
+            break;
+        }
+        case 'object': {
+            const result = JSON.parse(value);
+            if (result && typeof result === 'object') {
+                parent[key] = result;
+            }
+            break;
+        }
+        default:
+            break;
+    }
+};
+//# sourceMappingURL=csv.js.map

package/fs.d.ts

@@ -1,6 +1,6 @@
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
 import { type Dirent } from 'node:fs';
 import { type Promisable } from 'type-fest';
 /**

package/fs.test.js

@@ -40,7 +40,7 @@ describe('readData', () => {
 });
 describe('opendirSafe', () => {
     it('should read a directory', async () => {
-        const onFile = import.meta.jest.fn();
+        const onFile = vi.fn();
         await opendirSafe(resolveFixture('test'), onFile);
         expect(onFile).toHaveBeenCalledTimes(3);
         expect(onFile).toHaveBeenCalledWith(resolveFixture('test/bar.txt'), expect.objectContaining({ name: 'bar.txt' }));
@@ -48,7 +48,7 @@ describe('opendirSafe', () => {
         expect(onFile).toHaveBeenCalledWith(resolveFixture('test/z'), expect.objectContaining({ name: 'z' }));
     });
     it('should read a directory recursively if specified', async () => {
-        const onFile = import.meta.jest.fn();
+        const onFile = vi.fn();
         await opendirSafe(resolveFixture('test'), onFile, { recursive: true });
         expect(onFile).toHaveBeenCalledTimes(5);
         expect(onFile).toHaveBeenCalledWith(resolveFixture('test/bar.txt'), expect.objectContaining({ name: 'bar.txt' }));
@@ -59,15 +59,15 @@ describe('opendirSafe', () => {
     });
     it('should throw if the path is not a directory', async () => {
         const path = resolveFixture('hello.txt');
-        await expect(opendirSafe(path, import.meta.jest.fn())).rejects.toThrow(new AppsembleError(`Expected ${path} to be a directory`));
+        await expect(opendirSafe(path, vi.fn())).rejects.toThrow(new AppsembleError(`Expected ${path} to be a directory`));
     });
     it('should throw if the path doesn’t exist', async () => {
         const path = resolveFixture('non-existent');
-        await expect(opendirSafe(path, import.meta.jest.fn())).rejects.toThrow(new AppsembleError(`Expected ${path} to be a directory`));
+        await expect(opendirSafe(path, vi.fn())).rejects.toThrow(new AppsembleError(`Expected ${path} to be a directory`));
     });
     it('should not throw if the path doesn’t exist and allowMissing is true', async () => {
         const path = resolveFixture('non-existent');
-        const result = await opendirSafe(path, import.meta.jest.fn(), { allowMissing: true });
+        const result = await opendirSafe(path, vi.fn(), { allowMissing: true });
         expect(result).toBeUndefined();
     });
 });

package/getAppsembleMessages.d.ts

@@ -0,0 +1,9 @@
+export declare function getSupportedLanguages(): Promise<Set<string>>;
+/**
+ * Fetch and merge the Appsemble core messages based on a language and a base language.
+ *
+ * @param language The language to get the messages of.
+ * @param baseLanguage The base language of the language to get the messages of.
+ * @returns The Appsemble core messages.
+ */
+export declare function getAppsembleMessages(language: string, baseLanguage?: string): Promise<Record<string, string>>;

package/getAppsembleMessages.js

@@ -0,0 +1,32 @@
+import { readdir, readFile } from 'node:fs/promises';
+import { defaultLocale } from '@appsemble/utils';
+const translationsDir = new URL('../../i18n/', import.meta.url);
+export async function getSupportedLanguages() {
+    const files = await readdir(translationsDir);
+    return new Set(files.map((lang) => lang.split('.json')[0].toLowerCase()));
+}
+/**
+ * Fetch and merge the Appsemble core messages based on a language and a base language.
+ *
+ * @param language The language to get the messages of.
+ * @param baseLanguage The base language of the language to get the messages of.
+ * @returns The Appsemble core messages.
+ */
+export async function getAppsembleMessages(language, baseLanguage) {
+    const lang = language.toLowerCase();
+    const baseLang = baseLanguage === null || baseLanguage === void 0 ? void 0 : baseLanguage.toLowerCase();
+    const languages = await getSupportedLanguages();
+    const messages = {};
+    if (baseLang && languages.has(baseLanguage)) {
+        Object.assign(messages, JSON.parse(await readFile(new URL(`${baseLang}.json`, translationsDir), 'utf8')));
+    }
+    if (languages.has(lang)) {
+        Object.assign(messages, Object.fromEntries(Object.entries(JSON.parse(await readFile(new URL(`${lang}.json`, translationsDir), 'utf8'))).filter(([, value]) => Boolean(value))));
+    }
+    // Fall back to reading the default locale’s messages if no core messages were found.
+    if (!languages.has(lang) && (!baseLang || !languages.has(baseLang))) {
+        Object.assign(messages, JSON.parse(await readFile(new URL(`${defaultLocale}.json`, translationsDir), 'utf8')));
+    }
+    return messages;
+}
+//# sourceMappingURL=getAppsembleMessages.js.map

package/handleError.test.js

@@ -3,10 +3,10 @@ import { handleError } from './handleError.js';
 import { logger } from './logger.js';
 let yargs;
 beforeEach(() => {
-    yargs = { showHelp: import.meta.jest.fn() };
-    import.meta.jest.spyOn(console, 'error').mockImplementation();
-    import.meta.jest.spyOn(process, 'exit').mockImplementation();
-    import.meta.jest.spyOn(logger, 'error').mockImplementation();
+    yargs = { showHelp: vi.fn() };
+    vi.spyOn(console, 'error').mockImplementation(null);
+    vi.spyOn(process, 'exit').mockImplementation(() => null);
+    vi.spyOn(logger, 'error').mockImplementation(null);
 });
 it('should show the help message if it is passed a yargs message', () => {
     handleError('Command foo not found', undefined, yargs);

package/icon.d.ts

@@ -0,0 +1,44 @@
+/// <reference types="node" resolution-mode="require"/>
+import { type Context } from 'koa';
+import { type RGBA } from 'sharp';
+interface ServeIconOptions {
+    /**
+     * If specified, fill the background with this color.
+     */
+    background?: RGBA | string;
+    /**
+     * If true, cache the icon for a week / immutable.
+     */
+    cache?: boolean;
+    /**
+     * The name of a fallback icon to use.
+     */
+    fallback: string;
+    /**
+     * The height to scale the image to.
+     */
+    height?: number;
+    /**
+     * The icon to render.
+     */
+    icon?: Buffer;
+    /**
+     * If true, the maskable icon is preferred over the regular icon. If no maskable icon is defined,
+     * the icon will be scaled to fit within a maskable icon diameter (80% diameter).
+     */
+    maskable?: boolean;
+    /**
+     * The maskable icon to render if this is preferred.
+     */
+    maskableIcon?: Buffer;
+    /**
+     * If true, render the raw icon. In this case all other options are ignored.
+     */
+    raw?: boolean;
+    /**
+     * The width to scale the image to.
+     */
+    width?: number;
+}
+export declare function serveIcon(ctx: Context, { background, cache, fallback, height, icon, maskable, maskableIcon, raw, width, }: ServeIconOptions): Promise<void>;
+export {};

package/icon.js

@@ -0,0 +1,69 @@
+import sharp from 'sharp';
+import { readAsset } from './readAsset.js';
+/**
+ * A transparent background color used by sharp.
+ */
+const transparent = { r: 0, g: 0, b: 0, alpha: 0 };
+/**
+ * The diameter of the safe area for maskable icons.
+ *
+ * https://css-tricks.com/maskable-icons-android-maskable-icons-for-your-pwa/
+ */
+const safeAreaDiameter = 0.8;
+export async function serveIcon(ctx, { background, cache, fallback, height, icon, maskable, maskableIcon, raw, width, }) {
+    const buffer = (maskable && maskableIcon) || icon || (await readAsset(fallback));
+    let img = sharp(buffer);
+    if (raw) {
+        const { format } = await img.metadata();
+        ctx.body = buffer;
+        ctx.type = format;
+        return;
+    }
+    if (!maskable) {
+        // Serve the regular app icon, but scaled.
+        img.resize({
+            width,
+            height,
+            fit: 'contain',
+            background: background || transparent,
+        });
+        if (background) {
+            img.flatten({ background });
+        }
+    }
+    else if (maskableIcon) {
+        img.resize({ width, height, fit: 'cover' });
+        if (background) {
+            img.flatten({ background });
+        }
+    }
+    else {
+        // Make the regular icon maskable
+        const actual = img;
+        const metadata = await actual.metadata();
+        const angle = Math.atan(metadata.height / metadata.width);
+        actual.resize({
+            width: Math.ceil(Math.cos(angle) * safeAreaDiameter * width),
+            // By leaving out height, libvips will determine this for us. This has better precision than
+            // calculating this using JavasScript and passing it manually.
+            // height: Math.ceil(Math.sin(angle) * safeAreaDiameter * size),
+            fit: 'contain',
+            background,
+        });
+        img = sharp(Buffer.alloc(width * height * 4, 0), {
+            raw: { width, height, channels: 4 },
+        });
+        img.resize({ width, height });
+        img.composite([{ input: await actual.toFormat('png').toBuffer() }]);
+        if (background) {
+            img.flatten({ background });
+        }
+        // Cache app icons for 1 week.
+        if (cache) {
+            ctx.set('cache-control', `public, max-age=${60 * 60 * 24 * 7},immutable`);
+        }
+    }
+    ctx.body = await img.toFormat('png').toBuffer();
+    ctx.type = 'image/png';
+}
+//# sourceMappingURL=icon.js.map

package/index.d.ts

@@ -6,6 +6,27 @@ export * from './getWorkspaces.js';
 export * from './handleError.js';
 export * from './interceptors.js';
 export * from './logger.js';
-export * from './loggerMiddleware.js';
+export * from './middleware/loggerMiddleware.js';
+export * from './middleware/boom.js';
+export * from './middleware/conditional.js';
+export * from './middleware/frontend.js';
+export * from './parsers.js';
 export * from './readFileOrString.js';
 export * from './testFixtures.js';
+export * from './tinyRouter.js';
+export * from './icon.js';
+export * from './readAsset.js';
+export * from './render.js';
+export * from './getAppsembleMessages.js';
+export * from './odata.js';
+export * from './resource.js';
+export * from './app.js';
+export * from './mergeMessages.js';
+export * from './jsonschema.js';
+export * from './organizationBlocklist.js';
+export * from './scim.js';
+export * from './server/routes/appRouter/index.js';
+export * from './server/routes/appRouter/iconHandler.js';
+export * from './server/controllers/index.js';
+export * from './server/types.js';
+export * from './koa.js';

package/index.js

@@ -6,7 +6,28 @@ export * from './getWorkspaces.js';
 export * from './handleError.js';
 export * from './interceptors.js';
 export * from './logger.js';
-export * from './loggerMiddleware.js';
+export * from './middleware/loggerMiddleware.js';
+export * from './middleware/boom.js';
+export * from './middleware/conditional.js';
+export * from './middleware/frontend.js';
+export * from './parsers.js';
 export * from './readFileOrString.js';
 export * from './testFixtures.js';
+export * from './tinyRouter.js';
+export * from './icon.js';
+export * from './readAsset.js';
+export * from './render.js';
+export * from './getAppsembleMessages.js';
+export * from './odata.js';
+export * from './resource.js';
+export * from './app.js';
+export * from './mergeMessages.js';
+export * from './jsonschema.js';
+export * from './organizationBlocklist.js';
+export * from './scim.js';
+export * from './server/routes/appRouter/index.js';
+export * from './server/routes/appRouter/iconHandler.js';
+export * from './server/controllers/index.js';
+export * from './server/types.js';
+export * from './koa.js';
 //# sourceMappingURL=index.js.map

package/interceptors.test.js

@@ -8,9 +8,8 @@ function h(content) {
 }
 let instance;
 let mock;
-import.meta.jest.mock('os');
 beforeEach(() => {
-    import.meta.jest.useFakeTimers({ now: 0 });
+    vi.useFakeTimers({ now: 0 });
 });
 describe('formData', () => {
     beforeAll(() => {
@@ -46,7 +45,7 @@ describe('requestLogger', () => {
         mock.onAny().reply(200);
     });
     it('should log requests', async () => {
-        import.meta.jest.spyOn(logger, 'verbose');
+        vi.spyOn(logger, 'verbose');
         await instance.get('/');
         expect(logger.verbose).toHaveBeenCalledWith(`> 0 ${h('GET / HTTP/1.1')}`);
     });
@@ -59,15 +58,15 @@ describe('responseLogger', () => {
         mock.onAny().reply(200);
     });
     it('should log responses', async () => {
-        import.meta.jest.spyOn(logger, 'verbose');
+        vi.spyOn(logger, 'verbose');
         await instance.get('/');
         expect(logger.verbose).toHaveBeenCalledWith(expect.any(String));
     });
 });
 describe('configureAxios', () => {
     beforeEach(() => {
-        import.meta.jest.spyOn(axios.interceptors.request, 'use').mockImplementation();
-        import.meta.jest.spyOn(axios.interceptors.response, 'use').mockImplementation();
+        vi.spyOn(axios.interceptors.request, 'use').mockImplementation(null);
+        vi.spyOn(axios.interceptors.response, 'use').mockImplementation(null);
     });
     it('should set the correct user agent', () => {
         configureAxios('TestClient', '1.2.3');

package/jsonschema.d.ts

@@ -0,0 +1,2 @@
+import { type ValidatorResult } from 'jsonschema';
+export declare function handleValidatorResult(result: ValidatorResult, msg?: string): void;

package/jsonschema.js

@@ -0,0 +1,7 @@
+import { badRequest } from '@hapi/boom';
+export function handleValidatorResult(result, msg = 'JSON schema validation failed') {
+    if (!result.valid) {
+        throw badRequest(msg, { errors: result.errors });
+    }
+}
+//# sourceMappingURL=jsonschema.js.map

package/koa.d.ts

@@ -0,0 +1,6 @@
+import { type Plugin } from 'koas-core';
+declare function serializer(): Plugin;
+declare function bodyParser(): Plugin;
+export { bodyParser, serializer };
+export * from 'koas-parameters';
+export * from 'koas-security';

package/koa.js

@@ -0,0 +1,27 @@
+import { convertToCsv } from '@appsemble/utils';
+import { bufferParser, jsonParser, bodyParser as koaBodyParser } from 'koas-body-parser';
+import { serializer as koaSerializer } from 'koas-serializer';
+import { csvParser, xWwwFormUrlencodedParser } from './parsers.js';
+function serializer() {
+    return koaSerializer({
+        serializers: {
+            'application/scim+json': (body) => JSON.stringify(body),
+            'application/xml': (body) => body,
+            'text/csv': convertToCsv,
+        },
+    });
+}
+function bodyParser() {
+    return koaBodyParser({
+        parsers: {
+            'application/scim+json': jsonParser,
+            'application/x-www-form-urlencoded': xWwwFormUrlencodedParser,
+            'text/csv': csvParser,
+            '*/*': bufferParser,
+        },
+    });
+}
+export { bodyParser, serializer };
+export * from 'koas-parameters';
+export * from 'koas-security';
+//# sourceMappingURL=koa.js.map

package/mergeMessages.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Calls Lodash’s mergeWith function
+ * but with a comparator function provided to merge any string leaves if they are truthy.
+ *
+ * @param object The base object to merge.
+ * @param otherArgs A list of objects to merge.
+ * @returns The resulting merged object.
+ */
+export declare function mergeMessages(object: any, ...otherArgs: any[]): any;

package/mergeMessages.js

@@ -0,0 +1,17 @@
+import { mergeWith } from 'lodash-es';
+/**
+ * Calls Lodash’s mergeWith function
+ * but with a comparator function provided to merge any string leaves if they are truthy.
+ *
+ * @param object The base object to merge.
+ * @param otherArgs A list of objects to merge.
+ * @returns The resulting merged object.
+ */
+export function mergeMessages(object, ...otherArgs) {
+    return mergeWith(object, ...otherArgs, (objectValue, newValue) => {
+        if (typeof newValue === 'string') {
+            return newValue || objectValue;
+        }
+    });
+}
+//# sourceMappingURL=mergeMessages.js.map

package/middleware/boom.d.ts

@@ -0,0 +1,7 @@
+import { type Middleware } from 'koa';
+/**
+ * Koa middleware for handling Boom errors.
+ *
+ * @returns Koa middleware that converts Boom errors into an HTTP response.
+ */
+export declare function boomMiddleware(): Middleware;

package/middleware/boom.js

@@ -0,0 +1,32 @@
+import { SCIMError } from '../scim.js';
+/**
+ * Koa middleware for handling Boom errors.
+ *
+ * @returns Koa middleware that converts Boom errors into an HTTP response.
+ */
+export function boomMiddleware() {
+    return async (ctx, next) => {
+        try {
+            await next();
+        }
+        catch (error) {
+            if (error instanceof SCIMError) {
+                ctx.status = Number(error.status);
+                ctx.body = error;
+                return;
+            }
+            const err = error;
+            if (!err.isBoom) {
+                throw err;
+            }
+            const { output } = err;
+            ctx.status = output.statusCode;
+            ctx.body = output.payload;
+            if (err.data) {
+                ctx.body.data = err.data;
+            }
+            ctx.set(output.headers);
+        }
+    };
+}
+//# sourceMappingURL=boom.js.map

package/middleware/boom.test.js

@@ -0,0 +1,58 @@
+import { notFound, unauthorized } from '@hapi/boom';
+import { request, setTestApp } from 'axios-test-instance';
+import Koa from 'koa';
+import { boomMiddleware } from './boom.js';
+describe('boomMiddleware', () => {
+    let app;
+    beforeEach(async () => {
+        app = new Koa();
+        app.use(boomMiddleware());
+        await setTestApp(app);
+    });
+    it('should catch boom errors', async () => {
+        app.use(() => {
+            throw notFound('Error not found', "It's nowhere to be seen!");
+        });
+        const response = await request.get('/');
+        expect(response).toMatchObject({
+            status: 404,
+            data: {
+                statusCode: 404,
+                error: 'Not Found',
+                message: 'Error not found',
+                data: "It's nowhere to be seen!",
+            },
+        });
+    });
+    it('should rethrow non-boom errors', async () => {
+        app.silent = true;
+        const error = new Error('This is a test error');
+        let result;
+        app.use(() => {
+            throw error;
+        });
+        app.on('error', (err) => {
+            result = err;
+        });
+        await request.get('/');
+        expect(result).toBe(error);
+    });
+    it('should set Koa headers correctly', async () => {
+        app.use(() => {
+            throw unauthorized('Not authorized!', ['Basic realm="Access to test data", charset="UTF-8"']);
+        });
+        const response = await request.get('/');
+        expect(response).toMatchObject({
+            status: 401,
+            headers: expect.objectContaining({
+                'www-authenticate': 'Basic realm="Access to test data", charset="UTF-8"',
+            }),
+            data: {
+                statusCode: 401,
+                error: 'Unauthorized',
+                message: 'Not authorized!',
+            },
+        });
+    });
+});
+//# sourceMappingURL=boom.test.js.map

package/middleware/conditional.d.ts

@@ -0,0 +1,2 @@
+import { type Context, type Middleware } from 'koa';
+export declare function conditional(check: (ctx: Context) => boolean, middleware: Middleware): Middleware;