@appsemble/node-utils 0.20.45 → 0.21.1

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;

package/middleware/conditional.js

@@ -0,0 +1,9 @@
+export function conditional(check, middleware) {
+    return (ctx, next) => {
+        if (check(ctx)) {
+            return middleware(ctx, next);
+        }
+        return next();
+    };
+}
+//# sourceMappingURL=conditional.js.map

package/middleware/frontend.d.ts

@@ -0,0 +1,3 @@
+import { type Middleware } from 'koa';
+import { type Configuration } from 'webpack';
+export declare function frontend(webpackConfigs: Configuration[], argv: Record<string, any>, serveStudio?: boolean): Promise<Middleware>;

package/middleware/frontend.js

@@ -0,0 +1,40 @@
+import { isIP } from 'node:net';
+import expressToKoa from 'express-to-koa';
+import compose from 'koa-compose';
+import webpack from 'webpack';
+import webpackDevMiddleware from 'webpack-dev-middleware';
+/**
+ * Bypass the dev server for API requests to speed them up.
+ */
+const skipRoute = /^\/(api|oauth2\/token)/;
+export async function frontend(webpackConfigs, argv, serveStudio = false) {
+    // eslint-disable-next-line @typescript-eslint/prefer-ts-expect-error
+    // @ts-ignore Because the webpack core config isn’t built when building the server, an error is
+    // expected here at build time, but while type checking.
+    const { createAppConfig, createStudioConfig } = await import('@appsemble/webpack-core');
+    const configApp = createAppConfig({ mode: 'development' });
+    const configStudio = createStudioConfig({ mode: 'development' });
+    const configs = [configApp, ...(serveStudio ? [configStudio] : []), ...webpackConfigs];
+    const compiler = webpack(configs);
+    const devMiddleware = webpackDevMiddleware(compiler, { serverSideRender: true });
+    // @ts-expect-error outputFileSystem exists despite what the types say.
+    const fs = devMiddleware.context.outputFileSystem;
+    const koaDevMiddleware = expressToKoa(devMiddleware);
+    return compose([
+        (ctx, next) => {
+            ctx.fs = fs;
+            return next();
+        },
+        (ctx, next) => {
+            const { hostname } = ctx;
+            if (!skipRoute.test(ctx.path)) {
+                return koaDevMiddleware(ctx, next);
+            }
+            if (new URL(argv.host).hostname === hostname || isIP(hostname)) {
+                return next();
+            }
+            return koaDevMiddleware(ctx, next);
+        },
+    ]);
+}
+//# sourceMappingURL=frontend.js.map

package/{loggerMiddleware.js → middleware/loggerMiddleware.js}

@@ -1,5 +1,5 @@
 import chalk from 'chalk';
-import { logger } from './logger.js';
+import { logger } from '../logger.js';
 function rangeFormat(value, map) {
     return Object.entries(map).find(([v]) => v === 'default' || value < Number(v))[1];
 }

package/{loggerMiddleware.test.js → middleware/loggerMiddleware.test.js}

@@ -1,8 +1,7 @@
+import { logger, loggerMiddleware } from '@appsemble/node-utils';
 import { request, setTestApp } from 'axios-test-instance';
 import chalk from 'chalk';
 import Koa from 'koa';
-import { logger } from './logger.js';
-import { loggerMiddleware } from './loggerMiddleware.js';
 class TestError extends Error {
     constructor(message) {
         super(message);
@@ -11,9 +10,9 @@ class TestError extends Error {
 }
 let app;
 beforeEach(async () => {
-    import.meta.jest.spyOn(logger, 'info').mockImplementation(() => logger);
-    import.meta.jest.spyOn(logger, 'log').mockImplementation(() => logger);
-    import.meta.jest.useFakeTimers({ now: 0 });
+    vi.spyOn(logger, 'info').mockImplementation(() => logger);
+    vi.spyOn(logger, 'log').mockImplementation(() => logger);
+    vi.useFakeTimers();
     app = new Koa();
     app.use(async (ctx, next) => {
         Object.defineProperty(ctx.request, 'origin', {
@@ -40,7 +39,7 @@ it('should log requests', async () => {
 });
 it('should log success responses as info', async () => {
     app.use((ctx) => {
-        import.meta.jest.advanceTimersByTime(1);
+        vi.advanceTimersByTime(1);
         ctx.status = 200;
     });
     await request.get('/fries');
@@ -48,7 +47,7 @@ it('should log success responses as info', async () => {
 });
 it('should log redirect responses as info', async () => {
     app.use((ctx) => {
-        import.meta.jest.advanceTimersByTime(33);
+        vi.advanceTimersByTime(33);
         ctx.redirect('/');
     });
     await request.get('/fries');
@@ -56,7 +55,7 @@ it('should log redirect responses as info', async () => {
 });
 it('should log bad responses as warn', async () => {
     app.use((ctx) => {
-        import.meta.jest.advanceTimersByTime(3);
+        vi.advanceTimersByTime(3);
         ctx.status = 400;
     });
     await request.get('/burrito');
@@ -64,7 +63,7 @@ it('should log bad responses as warn', async () => {
 });
 it('should log error responses as error', async () => {
     app.use((ctx) => {
-        import.meta.jest.advanceTimersByTime(53);
+        vi.advanceTimersByTime(53);
         ctx.status = 503;
     });
     await request.get('/wrap');
@@ -72,7 +71,7 @@ it('should log error responses as error', async () => {
 });
 it('should log long request lengths yellow', async () => {
     app.use((ctx) => {
-        import.meta.jest.advanceTimersByTime(400);
+        vi.advanceTimersByTime(400);
         ctx.status = 200;
     });
     await request.get('/banana');
@@ -80,19 +79,19 @@ it('should log long request lengths yellow', async () => {
 });
 it('should log extremely long request lengths red', async () => {
     app.use((ctx) => {
-        import.meta.jest.advanceTimersByTime(1337);
+        vi.advanceTimersByTime(1337);
         ctx.status = 200;
     });
     await request.get('/pepperoni');
     expect(logger.log).toHaveBeenCalledWith('info', `${chalk.bold('GET')} https://example.com:1337/pepperoni ${chalk.green('200 OK')} ${chalk.red('1337ms')}`);
 });
 it('should log errors as internal server errors and rethrow', async () => {
-    const spy = import.meta.jest.fn();
+    const spy = vi.fn();
     const error = new Error('fail');
     let context;
     app.on('error', spy);
     app.use((ctx) => {
-        import.meta.jest.advanceTimersByTime(86);
+        vi.advanceTimersByTime(86);
         context = ctx;
         throw error;
     });
@@ -102,7 +101,7 @@ it('should log errors as internal server errors and rethrow', async () => {
 });
 it('should append the response length if it is defined', async () => {
     app.use((ctx) => {
-        import.meta.jest.advanceTimersByTime(1);
+        vi.advanceTimersByTime(1);
         ctx.status = 200;
         ctx.body = '{}';
     });
@@ -111,7 +110,7 @@ it('should append the response length if it is defined', async () => {
 });
 it('should log handled errors correctly', async () => {
     app.use(() => {
-        import.meta.jest.advanceTimersByTime(15);
+        vi.advanceTimersByTime(15);
         throw new TestError();
     });
     await request.get('potatoes');

package/odata.d.ts

@@ -0,0 +1,18 @@
+import { type Token } from '@odata/parser';
+export declare enum Edm {
+    null = "null",
+    Boolean = "Edm.Boolean",
+    Byte = "Edm.Byte",
+    Date = "Edm.Date",
+    DateTimeOffset = "Edm.DateTimeOffset",
+    Decimal = "Edm.Decimal",
+    Double = "Edm.Double",
+    Guid = "Edm.Guid",
+    Int16 = "Edm.Int16",
+    Int32 = "Edm.Int32",
+    Int64 = "Edm.Int64",
+    SByte = "Edm.SByte",
+    Single = "Edm.Single",
+    String = "Edm.String"
+}
+export declare function processLiteral(token: Token): Date | boolean | number | string;

package/odata.js

@@ -0,0 +1,45 @@
+export var Edm;
+(function (Edm) {
+    Edm["null"] = "null";
+    Edm["Boolean"] = "Edm.Boolean";
+    Edm["Byte"] = "Edm.Byte";
+    Edm["Date"] = "Edm.Date";
+    Edm["DateTimeOffset"] = "Edm.DateTimeOffset";
+    Edm["Decimal"] = "Edm.Decimal";
+    Edm["Double"] = "Edm.Double";
+    Edm["Guid"] = "Edm.Guid";
+    Edm["Int16"] = "Edm.Int16";
+    Edm["Int32"] = "Edm.Int32";
+    Edm["Int64"] = "Edm.Int64";
+    Edm["SByte"] = "Edm.SByte";
+    Edm["Single"] = "Edm.Single";
+    Edm["String"] = "Edm.String";
+})(Edm || (Edm = {}));
+export function processLiteral(token) {
+    switch (token.value) {
+        case Edm.Boolean:
+            return token.raw === 'true';
+        case Edm.String:
+            return JSON.parse(`"${token.raw.slice(1, -1).replaceAll('"', '\\"')}"`);
+        case Edm.Byte:
+        case Edm.Decimal:
+        case Edm.Double:
+        case Edm.Int16:
+        case Edm.Int32:
+        case Edm.Int64:
+        case Edm.SByte:
+        case Edm.Single:
+            return Number(token.raw);
+        case Edm.Date:
+        case Edm.DateTimeOffset:
+            // The Date constructor will convert it to UTC.
+            return new Date(token.raw);
+        case Edm.Guid:
+            return token.raw;
+        case Edm.null:
+            return null;
+        default:
+            throw new TypeError(`${token.position}: Unhandled OData literal type: ${token.value}`);
+    }
+}
+//# sourceMappingURL=odata.js.map

package/organizationBlocklist.d.ts

@@ -0,0 +1,4 @@
+/**
+ * A list of organization names that are not allowed to be used.
+ */
+export declare const organizationBlocklist: string[];

package/organizationBlocklist.js

@@ -0,0 +1,5 @@
+/**
+ * A list of organization names that are not allowed to be used.
+ */
+export const organizationBlocklist = ['www', 'api', 'email', 'mail', 'app'];
+//# sourceMappingURL=organizationBlocklist.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@appsemble/node-utils",
-  "version": "0.20.45",
+  "version": "0.21.1",
   "description": "NodeJS utilities used by Appsemble internally.",
   "keywords": [
     "app",
@@ -28,31 +28,71 @@
   ],
   "scripts": {
     "prepack": "tsc --noEmit false",
-    "test": "NODE_OPTIONS=--experimental-vm-modules jest"
+    "test": "vitest"
   },
   "dependencies": {
-    "@appsemble/utils": "0.20.45",
+    "@appsemble/types": "0.21.1",
+    "@appsemble/utils": "0.21.1",
+    "@formatjs/fast-memoize": "^2.0.0",
+    "@fortawesome/fontawesome-free": "^6.0.0",
+    "@hapi/boom": "^10.0.0",
+    "@koa/cors": "^4.0.0",
+    "@odata/parser": "^0.2.0",
     "@types/koa": "^2.0.0",
     "axios": "^1.0.0",
+    "bulma": "0.9.3",
+    "bulma-checkradio": "2.1.1",
+    "bulma-slider": "2.0.4",
+    "bulma-switch": "^2.0.0",
     "chalk": "^4.0.0",
     "cli-highlight": "^2.0.0",
+    "csv-parse": "^5.0.0",
+    "date-fns": "^2.0.0",
+    "express-to-koa": "^2.0.0",
     "fast-glob": "^3.0.0",
     "form-data": "^4.0.0",
+    "intl-messageformat": "^10.0.0",
+    "jsonschema": "^1.0.0",
     "koa": "^2.0.0",
     "koa-compose": "^4.0.0",
+    "koa-compress": "^5.0.0",
+    "koa-mount": "^4.0.0",
+    "koa-range": "^0.3.0",
+    "koa-static": "^5.0.0",
+    "koas-body-parser": "^0.7.0",
+    "koas-core": "^0.7.0",
+    "koas-operations": "^0.7.0",
+    "koas-parameters": "^0.7.0",
+    "koas-security": "^0.7.0",
+    "koas-serializer": "^0.7.0",
+    "koas-status-code": "^0.7.0",
+    "koas-swagger-ui": "^0.7.0",
+    "language-tags": "^1.0.0",
+    "lodash-es": "^4.0.0",
     "logform": "^2.0.0",
+    "mime-types": "^2.0.0",
+    "mustache": "^4.0.0",
+    "parse-duration": "^1.0.0",
     "parse-json": "^7.0.0",
+    "sass": "^1.0.0",
+    "sharp": "^0.32.0",
     "sort-keys": "^5.0.0",
-    "type-fest": "^3.0.0",
+    "strip-bom": "^5.0.0",
+    "type-fest": "^4.0.0",
+    "webpack": "^5.0.0",
+    "webpack-dev-middleware": "^6.0.0",
     "winston": "^3.0.0",
     "yaml": "^2.0.0",
     "yargs": "^17.0.0"
   },
   "devDependencies": {
     "@sinonjs/fake-timers": "^10.0.0",
+    "@types/koa-compress": "^4.0.0",
+    "@types/koa-range": "^0.3.0",
     "@types/sinonjs__fake-timers": "^8.0.0",
     "axios-mock-adapter": "^1.0.0",
-    "axios-test-instance": "^7.0.0"
+    "axios-test-instance": "^7.0.0",
+    "vitest": "^0.33.0"
   },
   "peerDependencies": {
     "prettier": "^2"

package/parsers.d.ts

@@ -0,0 +1,3 @@
+import { type Parser } from 'koas-body-parser';
+export declare const xWwwFormUrlencodedParser: Parser<unknown>;
+export declare const csvParser: Parser<unknown[]>;

package/parsers.js

@@ -0,0 +1,18 @@
+import { parse } from 'node:querystring';
+import { parse as parseCSV } from 'csv-parse';
+import { bufferParser } from 'koas-body-parser';
+export const xWwwFormUrlencodedParser = async (body, mediaTypeObject, options, ctx) => {
+    const buffer = await bufferParser(body, mediaTypeObject, options, ctx);
+    return parse(String(buffer));
+};
+export const csvParser = (body) => new Promise((resolve, reject) => {
+    body.pipe(parseCSV({ bom: true, columns: true }, (error, records) => {
+        if (error) {
+            reject(error);
+        }
+        else {
+            resolve(records);
+        }
+    }));
+});
+//# sourceMappingURL=parsers.js.map

package/readAsset.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+export declare const assetDir: import("url").URL;
+/**
+ * Read a file from the server assets directory.
+ *
+ * @param filename The path to the file to read, relative to the assets directory.
+ *
+ *   param encoding If specified, decode the file using this encoding.
+ * @returns The content of the specified file.
+ */
+export declare function readAsset(filename: string): Promise<Buffer>;
+export declare function readAsset(filename: string, encoding: BufferEncoding): Promise<string>;

package/readAsset.js

@@ -0,0 +1,6 @@
+import { readFile } from 'node:fs/promises';
+export const assetDir = new URL('assets/', import.meta.url);
+export function readAsset(filename, encoding) {
+    return readFile(new URL(filename, assetDir), encoding);
+}
+//# sourceMappingURL=readAsset.js.map

package/readFileOrString.d.ts

@@ -1,4 +1,4 @@
-/// <reference types="node" />
+/// <reference types="node" resolution-mode="require"/>
 /**
  * If the string represents an existing path, read the file. Otherwise, return the string itself.
  *

package/render.d.ts

@@ -0,0 +1,21 @@
+import { type ContentSecurityPolicy } from '@appsemble/node-utils';
+import { type Context } from 'koa';
+/**
+ * Render settings as an HTML script tag.
+ *
+ * @param settings The settings to render. This must be a JSON serializable object.
+ * @param statements Custom JavaScript statements to append.
+ * @returns A tuple of the digest and the HTML script tag. The digest should be added to the CSP
+ *   `script-src`.
+ */
+export declare function createSettings(settings: unknown, statements?: string[]): [digest: string, script: string];
+export declare function render(ctx: Context, filename: string, data: Record<string, unknown>): Promise<void>;
+/**
+ * Convert a CSP key / values pair object into a real content security policy string.
+ *
+ * Any falsy values will be excluded.
+ *
+ * @param csp The CSP object to convert
+ * @returns The CSP object as a string
+ */
+export declare function makeCSP(csp: ContentSecurityPolicy): string;

package/render.js

@@ -0,0 +1,46 @@
+import { createHash } from 'node:crypto';
+import { readFile } from 'node:fs/promises';
+import { compareStrings } from '@appsemble/utils';
+import mustache from 'mustache';
+/**
+ * Render settings as an HTML script tag.
+ *
+ * @param settings The settings to render. This must be a JSON serializable object.
+ * @param statements Custom JavaScript statements to append.
+ * @returns A tuple of the digest and the HTML script tag. The digest should be added to the CSP
+ *   `script-src`.
+ */
+export function createSettings(settings, statements = []) {
+    const script = [`window.settings=${JSON.stringify(settings)}`, ...statements].join(';');
+    const hash = createHash('sha256').update(script, 'utf8').digest('base64');
+    return [`'sha256-${hash}'`, `<script>${script}</script>`];
+}
+export async function render(ctx, filename, data) {
+    if (process.env.NODE_ENV === 'test') {
+        ctx.body = JSON.stringify({ filename, data });
+    }
+    else {
+        const template = await (process.env.NODE_ENV === 'production'
+            ? readFile(new URL(`../../dist/${filename}`, import.meta.url), 'utf8')
+            : ctx.fs.promises.readFile(`/${filename}`, 'utf8'));
+        ctx.body = mustache.render(template, data);
+    }
+    ctx.type = 'html';
+}
+/**
+ * Convert a CSP key / values pair object into a real content security policy string.
+ *
+ * Any falsy values will be excluded.
+ *
+ * @param csp The CSP object to convert
+ * @returns The CSP object as a string
+ */
+export function makeCSP(csp) {
+    return Object.entries(csp)
+        .map(([key, values]) => [key, values.filter(Boolean)])
+        .filter(([, values]) => values === null || values === void 0 ? void 0 : values.length)
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([key, values]) => `${key} ${[...new Set(values)].sort(compareStrings).join(' ')}`)
+        .join('; ');
+}
+//# sourceMappingURL=render.js.map

package/resource.d.ts

@@ -0,0 +1,43 @@
+import { type PreparedAsset } from '@appsemble/node-utils';
+import { type App, type ResourceDefinition } from '@appsemble/types';
+import { type PreValidatePropertyFunction } from 'jsonschema';
+import { type Context } from 'koa';
+import { type File } from 'koas-body-parser';
+/**
+ * Get the resource definition of an app by name.
+ *
+ * If there is no match, a 404 HTTP error is thrown.
+ *
+ * @param app The app to get the resource definition of
+ * @param resourceType The name of the resource definition to get.
+ * @param view The view that’s being used.
+ * @returns The matching resource definition.
+ */
+export declare function getResourceDefinition(app: App, resourceType: string, view?: string): ResourceDefinition;
+/**
+ * Extracts the IDs of resource request body.
+ *
+ * @param ctx The Koa context to extract the body from.
+ * @returns A tuple which consists of:
+ *
+ *   1. One or more resources processed from the request body.
+ *   2. A list of newly uploaded assets which should be linked to the resources.
+ *   3. preValidateProperty function used for reconstructing resources from a CSV file.
+ */
+export declare function extractResourceBody(ctx: Context): [Record<string, unknown> | Record<string, unknown>[], File[], PreValidatePropertyFunction];
+/**
+ * Process an incoming resource request body.
+ *
+ * This handles JSON schema validation, resource expiration, and asset linking and validation.
+ *
+ * @param ctx The Koa context to process.
+ * @param definition The resource definition to use for processing the request body.
+ * @param knownAssetIds A list of asset IDs that are already known to be linked to the resource.
+ * @param knownExpires A previously known expires value.
+ * @returns A tuple which consists of:
+ *
+ *   1. One or more resources processed from the request body.
+ *   2. A list of newly uploaded assets which should be linked to the resources.
+ *   3. Asset IDs from the `knownAssetIds` array which are no longer used.
+ */
+export declare function processResourceBody(ctx: Context, definition: ResourceDefinition, knownAssetIds?: string[], knownExpires?: Date): [Record<string, unknown> | Record<string, unknown>[], PreparedAsset[], string[]];