@appsemble/node-utils 0.30.14-test.5 → 0.32.1-test.14

package/middleware/loggerMiddleware.js

@@ -1,6 +1,7 @@
 import chalk from 'chalk';
 import { logger } from '../logger.js';
 function rangeFormat(value, map) {
+    // @ts-expect-error 2532 Object is possibly 'undefined'.
     return Object.entries(map).find(([v]) => v === 'default' || value < Number(v))[1];
 }
 /**

package/odata.js

@@ -20,7 +20,7 @@ export function processLiteral(token) {
         case Edm.Boolean:
             return token.raw === 'true';
         case Edm.String:
-            return JSON.parse(`"${token.raw.slice(1, -1).replaceAll('"', '\\"')}"`);
+            return JSON.parse(`"${token.raw.slice(1, -1).replaceAll('"', '\\"').replaceAll("''", "'")}"`);
         case Edm.Byte:
         case Edm.Decimal:
         case Edm.Double:
@@ -37,6 +37,7 @@ export function processLiteral(token) {
         case Edm.Guid:
             return token.raw;
         case Edm.null:
+            // @ts-expect-error 2322 null is not assignable to type (strictNullChecks) - Severe
             return null;
         default:
             throw new TypeError(`${token.position}: Unhandled OData literal type: ${token.value}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@appsemble/node-utils",
-  "version": "0.30.14-test.5",
+  "version": "0.32.1-test.14",
   "description": "NodeJS utilities used by Appsemble internally.",
   "keywords": [
     "app",
@@ -22,15 +22,17 @@
   "sideEffects": false,
   "type": "module",
   "exports": {
-    ".": [
-      "./index.js",
-      "./index.ts"
-    ]
+    ".": {
+      "ts-source": "./index.ts",
+      "default": "./index.js"
+    }
   },
   "files": [
     "**/*.d.ts",
     "**/*.js",
     "**/*.cjs",
+    "!**/*.test.js",
+    "!**/*.test.d.ts",
     "!*.config.js"
   ],
   "scripts": {
@@ -38,19 +40,19 @@
     "test": "vitest"
   },
   "dependencies": {
-    "@appsemble/types": "0.30.14-test.5",
-    "@appsemble/utils": "0.30.14-test.5",
+    "@appsemble/types": "0.32.1-test.14",
+    "@appsemble/utils": "0.32.1-test.14",
     "@formatjs/fast-memoize": "^2.0.0",
     "@fortawesome/fontawesome-free": "^6.0.0",
-    "@kubernetes/client-node": "0.21.0",
-    "@koa/cors": "^4.0.0",
+    "@kubernetes/client-node": "^0.22.2",
     "@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": "=0.9.3",
+    "bulma-checkradio": "=2.1.1",
+    "bulma-slider": "=2.0.4",
     "bulma-switch": "^2.0.0",
+    "busboy": "^1.6.0",
     "chalk": "^5.0.0",
     "cli-highlight": "^2.0.0",
     "css-tree": "^2.0.0",
@@ -62,7 +64,7 @@
     "fs-extra": "^11.0.0",
     "inquirer": "^9.0.0",
     "intl-messageformat": "^10.0.0",
-    "jsonschema": "^1.0.0",
+    "jsonschema": "~1.4.1",
     "keytar": "^7.0.0",
     "koa": "^2.0.0",
     "koa-compose": "^4.0.0",
@@ -82,8 +84,11 @@
     "lodash": "^4.0.0",
     "lodash-es": "^4.0.0",
     "logform": "^2.0.0",
+    "memfs": "^4.17.0",
     "mime-types": "^2.0.0",
+    "minio": "^8.0.3",
     "mustache": "^4.0.0",
+    "openapi-types": "^12.1.3",
     "parse-duration": "^1.0.0",
     "parse-json": "^8.0.0",
     "sass": "^1.0.0",
@@ -91,6 +96,7 @@
     "sort-keys": "^5.0.0",
     "strip-bom": "^5.0.0",
     "type-fest": "^4.0.0",
+    "type-is": "^1.6.18",
     "webpack": "^5.0.0",
     "webpack-dev-middleware": "^6.0.0",
     "winston": "^3.0.0",
@@ -98,12 +104,14 @@
     "yargs": "^17.0.0"
   },
   "devDependencies": {
+    "@types/busboy": "^1.5.4",
     "@types/css-tree": "^2.0.0",
     "@types/koa-compress": "^4.0.0",
     "@types/koa-range": "^0.3.0",
+    "@types/type-is": "^1.6.6",
     "axios-mock-adapter": "^1.0.0",
     "axios-test-instance": "^7.0.0",
-    "vitest": "^1.0.0"
+    "vitest": "^2.0.0"
   },
   "peerDependencies": {
     "prettier": "^3"

package/parsers.d.ts

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

package/parsers.js

@@ -1,6 +1,15 @@
+import { randomUUID } from 'node:crypto';
+import { createWriteStream } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
 import { parse } from 'node:querystring';
+import busboy from 'busboy';
 import { parse as parseCSV } from 'csv-parse';
 import { bufferParser } from 'koas-body-parser';
+import { SchemaValidationError } from 'koas-core';
+import { is } from 'type-is';
+import { logger } from './logger.js';
+import { TempFile } from './server/types.js';
 export const xWwwFormUrlencodedParser = async (body, mediaTypeObject, options, ctx) => {
     const buffer = await bufferParser(body, mediaTypeObject, options, ctx);
     return parse(String(buffer));
@@ -15,4 +24,125 @@ export const csvParser = (body) => new Promise((resolve, reject) => {
         }
     }));
 });
+/**
+ * Parse a raw string value based on a JSON schema.
+ *
+ * @param schema The JSON schema whose type to use for parsing the value.
+ * @param content The value to parse.
+ * @returns The parsed value.
+ */
+function fromString(schema, content) {
+    switch (schema?.type) {
+        case 'integer':
+        case 'number':
+            return Number(content);
+        case 'boolean':
+            if (content === 'true') {
+                return true;
+            }
+            if (content === 'false') {
+                return false;
+            }
+            return content;
+        case 'object':
+            try {
+                return JSON.parse(content);
+            }
+            catch {
+                return content;
+            }
+        default:
+            return content;
+    }
+}
+// Taken from https://gitlab.com/remcohaszing/koas/-/blob/main/packages/koas-body-parser/src/parsers/formdata.ts
+// Files are passed as streams rather than buffers
+export const streamParser = async (body, mediaTypeObject, { resolveRef }, ctx) => {
+    const bb = busboy({ headers: ctx.req.headers });
+    const { encoding = {}, schema } = mediaTypeObject || {};
+    const { properties = {} } = resolveRef(schema) || {};
+    const response = {};
+    const tempFiles = {};
+    await new Promise((resolve, reject) => {
+        function onError(error) {
+            bb.removeAllListeners();
+            logger.error(error);
+            reject(error);
+        }
+        bb.on('file', (fieldName, stream, { filename, mimeType: mime }) => {
+            const propertySchema = resolveRef(properties[fieldName]);
+            const path = join(tmpdir(), `${Date.now()}-${randomUUID()}`);
+            try {
+                const fileWriteStream = createWriteStream(path);
+                stream.pipe(fileWriteStream);
+                stream.on('error', onError);
+                fileWriteStream.on('error', onError);
+            }
+            catch (error) {
+                onError(error);
+            }
+            if (propertySchema && propertySchema.type === 'array') {
+                if (!Object.hasOwnProperty.call(response, fieldName)) {
+                    response[fieldName] = [];
+                }
+                if (!Object.hasOwnProperty.call(tempFiles, fieldName)) {
+                    tempFiles[fieldName] = [];
+                }
+                response[fieldName].push('');
+                tempFiles[fieldName].push(new TempFile({ path, mime, filename }));
+            }
+            else {
+                response[fieldName] = '';
+                tempFiles[fieldName] = new TempFile({ path, mime, filename });
+            }
+        })
+            .on('field', (fieldName, content) => {
+            const propertySchema = resolveRef(properties[fieldName]);
+            if (propertySchema && propertySchema.type === 'array') {
+                if (!Object.hasOwnProperty.call(response, fieldName)) {
+                    response[fieldName] = [];
+                }
+                response[fieldName].push(fromString(resolveRef(propertySchema.items), content));
+            }
+            else {
+                response[fieldName] = fromString(propertySchema, content);
+            }
+        })
+            .on('close', () => {
+            bb.removeAllListeners();
+            resolve(response);
+        })
+            .on('error', onError)
+            .on('partsLimit', onError)
+            .on('filesLimit', onError)
+            .on('fieldsLimit', onError);
+        ctx.req.pipe(bb);
+    });
+    // @ts-expect-error 2345 argument of type is not assignable to parameter of type
+    // (strictNullChecks) (schema may be undefined for some reason)
+    const result = ctx.openApi.validate(response, schema, { throw: false });
+    for (const [key, values] of Object.entries(tempFiles)) {
+        const vals = Array.isArray(values) ? values : [values];
+        for (const [index, value] of vals.entries()) {
+            if (!encoding?.[key]?.contentType) {
+                continue;
+            }
+            if (!is(value.mime, encoding[key].contentType.split(',').map((contentType) => contentType.trim()))) {
+                const error = result.addError({
+                    name: 'contentType',
+                    argument: encoding[key].contentType,
+                    message: 'has an invalid content type',
+                });
+                error.schema = {};
+                error.path = values === value ? [key] : [key, index];
+                error.property = values === value ? `instance.${key}` : `instance.${key}[${index}]`;
+            }
+        }
+    }
+    if (!result.valid) {
+        throw new SchemaValidationError('Invalid content types found', { result });
+    }
+    return Object.assign(response, tempFiles);
+};
+streamParser.skipValidation = true;
 //# sourceMappingURL=parsers.js.map

package/render.js

@@ -37,7 +37,7 @@ export async function render(ctx, filename, data) {
  */
 export function makeCSP(csp) {
     return Object.entries(csp)
-        .map(([key, values]) => [key, values.filter(Boolean)])
+        .map(([key, values]) => [key, values.filter((val) => val !== false && val != null)])
         .filter(([, values]) => values?.length)
         .sort(([a], [b]) => a.localeCompare(b))
         .map(([key, values]) => `${key} ${[...new Set(values)].sort(compareStrings).join(' ')}`)

package/resource.d.ts

@@ -1,9 +1,20 @@
 import { type AppDefinition, type ResourceDefinition, type Resource as ResourceType } from '@appsemble/types';
 import { type PreValidatePropertyFunction } from 'jsonschema';
 import { type Context, type DefaultContext, type DefaultState, type ParameterizedContext } from 'koa';
-import { type File } from 'koas-body-parser';
-import { type PreparedAsset } from './index.js';
+import { type JsonValue } from 'type-fest';
+import { type PreparedAsset, TempFile } from './index.js';
 export declare function stripResource({ $author, $created, $editor, $ephemeral, $group, $seed, $updated, ...data }: ResourceType): Record<string, unknown>;
+/**
+ * Works on a resource, which has been processed on the server by the streamParser
+ *
+ * @param data The resource to be serialized, optionally containing parsed TempFile instance assets
+ * @returns An object containing the resource and an array of the assets referenced
+ *   from the resource
+ */
+export declare function serializeServerResource(data: any): JsonValue | {
+    resource: JsonValue;
+    assets: TempFile[];
+};
 /**
  * Get the resource definition of an app by name.
  *
@@ -26,7 +37,11 @@ export declare function getResourceDefinition(appDefinition: AppDefinition, reso
  *   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 | ParameterizedContext<DefaultState, DefaultContext, any>): [Record<string, unknown> | Record<string, unknown>[], File[], PreValidatePropertyFunction];
+export declare function extractResourceBody(ctx: Context | ParameterizedContext<DefaultState, DefaultContext, any>): [
+    Record<string, unknown> | Record<string, unknown>[],
+    TempFile[],
+    PreValidatePropertyFunction | undefined
+];
 /**
  * Process an incoming resource request body.
  *

package/resource.js

@@ -1,13 +1,47 @@
 import { randomUUID } from 'node:crypto';
+import { mapValues } from '@appsemble/utils';
 import { addMilliseconds, isPast, parseISO } from 'date-fns';
 import { ValidationError, Validator } from 'jsonschema';
 import parseDuration from 'parse-duration';
 import { preProcessCSV } from './csv.js';
-import { handleValidatorResult } from './index.js';
+import { handleValidatorResult, TempFile } from './index.js';
 import { throwKoaError } from './koa.js';
 export function stripResource({ $author, $created, $editor, $ephemeral, $group, $seed, $updated, ...data }) {
     return data;
 }
+/**
+ * Works on a resource, which has been processed on the server by the streamParser
+ *
+ * @param data The resource to be serialized, optionally containing parsed TempFile instance assets
+ * @returns An object containing the resource and an array of the assets referenced
+ *   from the resource
+ */
+export function serializeServerResource(data) {
+    const assets = [];
+    const extractAssets = (value) => {
+        if (Array.isArray(value)) {
+            return value.map(extractAssets);
+        }
+        if (value instanceof TempFile) {
+            return String(assets.push(value) - 1);
+        }
+        if (value instanceof Date) {
+            return value.toJSON();
+        }
+        if (value && typeof value === 'object') {
+            return mapValues(value, extractAssets);
+        }
+        return value;
+    };
+    const resource = extractAssets(data);
+    if (!assets.length) {
+        return resource;
+    }
+    return {
+        resource,
+        assets,
+    };
+}
 /**
  * Get the resource definition of an app by name.
  *
@@ -37,7 +71,7 @@ export function getResourceDefinition(appDefinition, resourceType, ctx, view) {
             throwKoaError(ctx, 404, `App does not have resources called ${resourceType}`);
         }
     }
-    if (view && !definition.views[view]) {
+    if (view && !definition.views?.[view]) {
         if (ctx === undefined) {
             throw new Error(`View ${view} does not exist for resource type ${resourceType}`);
         }
@@ -118,21 +152,22 @@ export function processResourceBody(ctx, definition, knownAssetIds = [], knownEx
             regularAssets.push(asset);
         }
     }
-    const preparedRegularAssets = regularAssets.map(({ contents, filename, mime }, index) => {
+    const preparedRegularAssets = regularAssets.map(({ filename, mime, path }, index) => {
         const id = randomUUID();
         assetIdMap.set(index, id);
         assetUsedMap.set(index, false);
-        return { data: contents, filename, id, mime };
+        return { path, filename, id, mime };
     });
     const usedPreparedRegularAssets = [];
-    const preparedThumbnailAssets = thumbnailAssets.map(({ contents, filename, mime }, index) => {
+    const preparedThumbnailAssets = thumbnailAssets.map(({ filename, mime, path }, index) => {
         const regularAsset = preparedRegularAssets.find((ra) => !usedPreparedRegularAssets.includes(ra.id) &&
-            ra.filename.startsWith(filename.replace(thumbnailAssetSuffix, '')));
+            ra.filename?.startsWith(filename.replace(thumbnailAssetSuffix, '')));
         const id = regularAsset ? `${regularAsset.id}-thumbnail` : randomUUID();
+        // @ts-expect-error 2322 null is not assignable to type (strictNullChecks) - Severe
         usedPreparedRegularAssets.push(regularAsset?.id);
         assetIdMap.set(index + preparedRegularAssets.length, id);
         assetUsedMap.set(index, false);
-        return { data: contents, filename, id, mime };
+        return { path, filename, id, mime };
     });
     const preparedAssets = [...preparedRegularAssets, ...preparedThumbnailAssets];
     validator.customFormats.binary = (input) => {
@@ -202,11 +237,13 @@ export function processResourceBody(ctx, definition, knownAssetIds = [], knownEx
                 if (value !== undefined) {
                     const date = parseISO(value);
                     if (Number.isNaN(date.getTime())) {
+                        // @ts-expect-error 2345 argument of type is not assignable to parameter of type
+                        // (strictNullChecks) - Severe
                         return addMilliseconds(new Date(), parseDuration(value));
                     }
                     if (isPast(date) &&
                         !customErrors.some((error) => error.message === 'has already passed' && error.path === path)) {
-                        customErrors.push(new ValidationError('has already passed', value, null, path));
+                        customErrors.push(new ValidationError('has already passed', value, undefined, path));
                     }
                     return date;
                 }
@@ -235,7 +272,10 @@ export function processResourceBody(ctx, definition, knownAssetIds = [], knownEx
             }
             const uuid = assetIdMap.get(num);
             const currentResource = Array.isArray(resource) ? resource[path[0]] : resource;
-            preparedAssets.find((asset) => asset.id === uuid).resource = currentResource;
+            const preparedAsset = preparedAssets.find((asset) => asset.id === uuid);
+            if (preparedAsset) {
+                preparedAsset.resource = currentResource;
+            }
             assetUsedMap.set(num, true);
             return uuid;
         },
@@ -243,7 +283,7 @@ export function processResourceBody(ctx, definition, knownAssetIds = [], knownEx
     result.errors.push(...customErrors);
     for (const [assetId, used] of assetUsedMap.entries()) {
         if (!used) {
-            result.errors.push(new ValidationError('is not referenced from the resource', assetId, null, ['assets', assetId], 'binary', 'format'));
+            result.errors.push(new ValidationError('is not referenced from the resource', assetId, undefined, ['assets', assetId], 'binary', 'format'));
         }
     }
     handleValidatorResult(ctx, result, 'Resource validation failed');

package/s3.d.ts

@@ -0,0 +1,18 @@
+import { type Readable } from 'node:stream';
+import { type BucketItemStat } from 'minio';
+export interface InitS3ClientParams {
+    endPoint: string;
+    port?: number;
+    useSSL?: boolean;
+    accessKey: string;
+    secretKey: string;
+}
+export declare function initS3Client({ accessKey, endPoint, port, secretKey, useSSL, }: InitS3ClientParams): void;
+export declare function uploadS3File(bucket: string, key: string, content: Buffer | Readable | string, size?: number): Promise<void>;
+export declare function uploadS3FileFromPath(bucket: string, key: string, path: string): Promise<void>;
+export declare function getS3File(bucket: string, key: string): Promise<Readable>;
+export declare function getS3FileBuffer(bucket: string, key: string): Promise<Buffer>;
+export declare function getS3FileStats(bucket: string, key: string): Promise<BucketItemStat>;
+export declare function deleteS3File(bucket: string, key: string): Promise<void>;
+export declare function deleteS3Files(bucket: string, keys: string[]): Promise<void>;
+export declare function clearAllS3Buckets(): Promise<void>;

package/s3.js

@@ -0,0 +1,131 @@
+import { streamToBuffer } from 'memfs/lib/node/util.js';
+import { Client, S3Error } from 'minio';
+import { logger } from './logger.js';
+let s3Client;
+export function initS3Client({ accessKey, endPoint, port = 9000, secretKey, useSSL = true, }) {
+    try {
+        s3Client = new Client({
+            endPoint,
+            port,
+            useSSL,
+            accessKey,
+            secretKey,
+        });
+    }
+    catch (error) {
+        logger.error(error);
+        throw error;
+    }
+}
+async function ensureBucket(name) {
+    try {
+        const bucketExists = await s3Client.bucketExists(name);
+        if (!bucketExists) {
+            try {
+                await s3Client.makeBucket(name);
+            }
+            catch (makeBucketError) {
+                if (makeBucketError instanceof S3Error &&
+                    makeBucketError.code === 'BucketAlreadyOwnedByYou') {
+                    logger.warn(makeBucketError);
+                    logger.info('This was probably called in an asynchronous batch upload.');
+                }
+                else {
+                    throw makeBucketError;
+                }
+            }
+        }
+    }
+    catch (error) {
+        logger.error(error);
+        throw error;
+    }
+}
+export async function uploadS3File(bucket, key, content, size) {
+    try {
+        await ensureBucket(bucket);
+        await s3Client.putObject(bucket, key, content, size);
+    }
+    catch (error) {
+        logger.error(error);
+        throw error;
+    }
+}
+export async function uploadS3FileFromPath(bucket, key, path) {
+    try {
+        await ensureBucket(bucket);
+        await s3Client.fPutObject(bucket, key, path);
+    }
+    catch (error) {
+        logger.error(error);
+        throw error;
+    }
+}
+export async function getS3File(bucket, key) {
+    try {
+        return await s3Client.getObject(bucket, key);
+    }
+    catch (error) {
+        logger.error(error);
+        // @ts-expect-error 2322 null is not assignable to type (strictNullChecks) - Severe
+        return null;
+    }
+}
+export async function getS3FileBuffer(bucket, key) {
+    try {
+        const stream = await getS3File(bucket, key);
+        // @ts-expect-error 2322 null is not assignable to type (strictNullChecks) - Severe
+        return stream ? streamToBuffer(stream) : null;
+    }
+    catch (error) {
+        logger.error(error);
+        // @ts-expect-error 2322 null is not assignable to type (strictNullChecks) - Severe
+        return null;
+    }
+}
+export async function getS3FileStats(bucket, key) {
+    try {
+        return await s3Client.statObject(bucket, key);
+    }
+    catch (error) {
+        logger.error(error);
+        throw error;
+    }
+}
+export async function deleteS3File(bucket, key) {
+    try {
+        await s3Client.removeObject(bucket, key);
+    }
+    catch (error) {
+        logger.error(error);
+        throw error;
+    }
+}
+export async function deleteS3Files(bucket, keys) {
+    try {
+        await s3Client.removeObjects(bucket, keys);
+    }
+    catch (error) {
+        logger.error(error);
+        throw error;
+    }
+}
+export async function clearAllS3Buckets() {
+    try {
+        const buckets = await s3Client.listBuckets();
+        for (const bucket of buckets) {
+            const objectsStream = s3Client.listObjectsV2(bucket.name, '', true);
+            const objects = [];
+            for await (const o of objectsStream) {
+                objects.push(o.name);
+            }
+            await s3Client.removeObjects(bucket.name, objects);
+            await s3Client.removeBucket(bucket.name);
+        }
+    }
+    catch (error) {
+        logger.error(error);
+        throw error;
+    }
+}
+//# sourceMappingURL=s3.js.map

package/server/controllers/common/apps/assets/createGetAppAssetByIdController.js

@@ -1,15 +1,16 @@
 import { extension } from 'mime-types';
-import { assertKoaError } from '../../../../../koa.js';
+import { assertKoaCondition } from '../../../../../koa.js';
 export function createGetAppAssetByIdController({ getApp, getAppAsset }) {
     return async (ctx) => {
         const { pathParams: { appId, assetId }, } = ctx;
         const app = await getApp({ context: ctx, query: { where: { id: appId } } });
-        assertKoaError(!app, ctx, 404, 'App not found');
+        assertKoaCondition(app != null, ctx, 404, 'App not found');
         const asset = await getAppAsset({ app, context: ctx, id: assetId });
         if (assetId !== asset.id) {
             // Redirect to asset using current asset ID
             ctx.status = 302;
             ctx.set('location', `/api/apps/${app.id}/assets/${asset.id}`);
+            // @ts-expect-error 2322 null is not assignable to type (strictNullChecks)
             ctx.type = null;
             return;
         }
@@ -28,7 +29,7 @@ export function createGetAppAssetByIdController({ getApp, getAppAsset }) {
             ctx.set('content-disposition', `attachment; filename=${JSON.stringify(filename)}`);
         }
         ctx.set('Cache-Control', 'max-age=31536000,immutable');
-        ctx.body = asset.data;
+        ctx.body = asset.stream;
     };
 }
 //# sourceMappingURL=createGetAppAssetByIdController.js.map

package/server/controllers/common/apps/groups/createGetAppGroupsController.js

@@ -1,10 +1,10 @@
 import { AppPermission } from '@appsemble/types';
-import { assertKoaError } from '../../../../../koa.js';
+import { assertKoaCondition } from '../../../../../koa.js';
 export function createGetAppGroupsController({ checkAuthSubjectAppPermissions, getApp, getAppGroups, }) {
     return async (ctx) => {
         const { pathParams: { appId }, } = ctx;
         const app = await getApp({ context: ctx, query: { where: { id: appId } } });
-        assertKoaError(!app, ctx, 404, 'App not found');
+        assertKoaCondition(app != null, ctx, 404, 'App not found');
         await checkAuthSubjectAppPermissions({
             app,
             context: ctx,

package/server/controllers/common/apps/messages/createGetAppMessagesController.js

@@ -2,6 +2,8 @@ import { getMessagesUtil } from '../../../../../index.js';
 export function createGetAppMessagesController(options) {
     return async (ctx) => {
         const { pathParams: { appId, language }, query: { merge, override = 'true' }, } = ctx;
+        // @ts-expect-error 2345 argument of type is not assignable to parameter of type
+        // (strictNullChecks)
         ctx.body = await getMessagesUtil(ctx, language, appId, merge, options, override);
     };
 }