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

package/README.md

@@ -1,9 +1,9 @@
-# ![](https://gitlab.com/appsemble/appsemble/-/raw/0.30.14-test.6/config/assets/logo.svg) Appsemble Node Utilities
+# ![](https://gitlab.com/appsemble/appsemble/-/raw/0.32.1-test.14/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.30.14-test.6/pipeline.svg)](https://gitlab.com/appsemble/appsemble/-/releases/0.30.14-test.6)
+[![GitLab CI](https://gitlab.com/appsemble/appsemble/badges/0.32.1-test.14/pipeline.svg)](https://gitlab.com/appsemble/appsemble/-/releases/0.32.1-test.14)
 [![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.30.14-test.6/LICENSE.md) ©
+[LGPL-3.0-only](https://gitlab.com/appsemble/appsemble/-/blob/0.32.1-test.14/LICENSE.md) ©
 [Appsemble](https://appsemble.com)

package/app.js

@@ -36,23 +36,30 @@ export async function getRemapperContext(app, language, options, context) {
     const appMemberInfo = await getCurrentAppMember({ context });
     const cache = objectCache((message) => new IntlMessageFormat(message, language, undefined, {
         formatters: {
+            // XXX: idk
+            // @ts-expect-error 2322 undefined is not assignable to type ... (strictNullChecks)
             getNumberFormat,
             getPluralRules,
             getDateTimeFormat: memoize((locale, opts) => new Intl.DateTimeFormat(locale, { ...opts, timeZone: appMemberInfo?.zoneinfo })),
         },
     }));
     return {
+        // @ts-expect-error 2322 null is not assignable to type (strictNullChecks)
         appId: app.id,
         appUrl,
         url: appUrl,
         getMessage({ defaultMessage, id }) {
+            // @ts-expect-error 2345 argument of type is not assignable to parameter of type
+            // (strictNullChecks)
             const msg = appMessages.find(({ messages }) => has(messages.messageIds, id));
+            // @ts-expect-error 2538 type undefined cannot be used as an index type
             const message = msg ? msg.messages.messageIds[id] : defaultMessage;
             return cache(message || `'{${id}}'`);
         },
         getVariable(variableName) {
             return appVariables.find((appVariable) => appVariable.name === variableName)?.value;
         },
+        // @ts-expect-error 2322 null is not assignable to type (strictNullChecks)
         appMemberInfo,
         context: {},
         locale: appMemberInfo?.locale ?? app.definition.defaultLanguage ?? defaultLocale,
@@ -150,6 +157,7 @@ async function patchStyle(replacementsPath, replacements) {
             parseValue: false,
         });
         for (const { property, selector, value } of replacements) {
+            // @ts-expect-error 2322 undefined is not assignable to type (strictNullChecks)
             doc = replaceStyle(doc, selector, property, String(value));
         }
         await writeFile(replacementsPath, generate(doc));

package/assets.d.ts

@@ -0,0 +1,16 @@
+import { type Context } from 'koa';
+import { type BucketItemStat } from 'minio';
+export declare function setAssetHeaders(ctx: Context, mime: string, filename: string | null, stats?: BucketItemStat): void;
+interface FileMeta {
+    filename?: string;
+    mime: string;
+}
+export declare function getCompressedFileMeta({ filename, mime }: FileMeta): FileMeta;
+export interface AssetToUpload {
+    id: string;
+    mime: string;
+    path: string;
+}
+export declare function uploadAsset(appId: number, asset: AssetToUpload): Promise<string[]>;
+export declare function uploadAssets(appId: number, assets: AssetToUpload[]): Promise<void>;
+export {};

package/assets.js

@@ -0,0 +1,65 @@
+import { createReadStream } from 'node:fs';
+import { stat } from 'node:fs/promises';
+import sharp from 'sharp';
+import { logger } from './logger.js';
+import { uploadS3File } from './s3.js';
+import { removeUploads } from './uploads.js';
+export function setAssetHeaders(ctx, mime, filename, stats) {
+    ctx.set('content-type', mime || 'application/octet-stream');
+    if (filename) {
+        ctx.set('content-disposition', `${mime?.startsWith('image') ? 'inline' : 'attachment'}; filename=${JSON.stringify(filename)}`);
+    }
+    if (stats) {
+        ctx.set('Content-Length', String(stats.size));
+        ctx.set('ETag', stats.etag);
+        ctx.set('Last-Modified', stats.lastModified.toUTCString());
+    }
+    ctx.set('Access-Control-Expose-Headers', 'Content-Disposition');
+    ctx.set('Cache-Control', 'max-age=31536000,immutable');
+}
+const ignoredMimes = new Set(['image/avif']);
+export function getCompressedFileMeta({ filename, mime }) {
+    if (mime?.startsWith('image') && !ignoredMimes.has(mime)) {
+        return {
+            filename: filename
+                ? filename.includes('.')
+                    ? `${filename.slice(0, filename.lastIndexOf('.'))}.avif`
+                    : `${filename}.avif`
+                : undefined,
+            mime: 'image/avif',
+        };
+    }
+    return { filename, mime };
+}
+export async function uploadAsset(appId, asset) {
+    const { id, mime, path } = asset;
+    const filesToUnlink = [path];
+    let uploadFrom = path;
+    if (mime?.startsWith('image') && !ignoredMimes.has(mime)) {
+        uploadFrom = `${path}_compressed`;
+        await sharp(path).rotate().toFormat('avif').toFile(uploadFrom);
+        filesToUnlink.push(uploadFrom);
+    }
+    try {
+        const stats = await stat(uploadFrom);
+        const stream = createReadStream(uploadFrom);
+        await uploadS3File(`app-${appId}`, id, stream, stats.size);
+    }
+    catch (error) {
+        logger.error(error);
+    }
+    return filesToUnlink;
+}
+export async function uploadAssets(appId, assets) {
+    const filesToUnlink = [];
+    for (const asset of assets) {
+        const toUnlink = await uploadAsset(appId, asset);
+        for (const path of toUnlink) {
+            if (!filesToUnlink.includes(path)) {
+                filesToUnlink.push(path);
+            }
+        }
+    }
+    await removeUploads(filesToUnlink);
+}
+//# sourceMappingURL=assets.js.map

package/authentication.d.ts

@@ -9,4 +9,4 @@ export declare function getKeytar(): Promise<typeof import('keytar')>;
  *   multiple scopes.
  * @param inputCredentials Client credentials passed from the command line.
  */
-export declare function authenticate(remote: string, scope: string, inputCredentials: string): Promise<void>;
+export declare function authenticate(remote: string, scope: string, inputCredentials?: string): Promise<void>;

package/container/helpers.d.ts

@@ -28,6 +28,6 @@ export declare function parseServiceUrl(url: string): {
     appName: string;
     namespace: string;
 };
-export declare function validateContainerResources(resources: ContainerResources): ContainerResources;
+export declare function validateContainerResources(resources?: ContainerResources): ContainerResources;
 export declare function isWhitelisted(fullImageName: string): Boolean;
 export declare function formatEnv(input: ContainerEnvVar[], appName: string, appId: string): V1EnvVar[];

package/container/helpers.js

@@ -70,6 +70,7 @@ export function parseServiceUrl(url) {
     const namespace = elements[1];
     const appId = deploymentName.split('-').pop();
     const appName = deploymentName.replace(`-${appId}`, '');
+    // @ts-expect-error 2322 null is not assignable to type (strictNullChecks)
     return { deploymentName, appId, appName, namespace };
 }
 export function validateContainerResources(resources) {

package/container/logs.js

@@ -66,19 +66,22 @@ export async function getLogs(deploymentName, fromAppsemble) {
     for (const pod of pods.items) {
         if (pod.metadata?.ownerReferences?.find((r) => r.kind === 'ReplicaSet') &&
             pod.status?.phase === 'Running') {
-            if (fromAppsemble && !pod.metadata?.name.includes(appsembleServiceName)) {
+            if (fromAppsemble && !pod.metadata?.name?.includes(appsembleServiceName)) {
                 continue;
             }
-            if (!fromAppsemble && !pod.metadata?.name.includes(deploymentName)) {
+            if (!fromAppsemble && !pod.metadata?.name?.includes(deploymentName)) {
                 continue;
             }
             logger.silly(`Pod: ${pod.metadata?.name}, status: ${pod.status}, deployment: ${deploymentName}`);
             try {
-                const res = await fetchLogs(fromAppsemble ? appsembleNamespace : containerNamespace, pod.metadata?.name, fromAppsemble ? 'appsemble' : deploymentName);
+                const res = await fetchLogs(fromAppsemble ? appsembleNamespace : containerNamespace, 
+                // @ts-expect-error 2345 argument of type is not assignable to parameter of type
+                // (strictNullChecks)
+                pod.metadata?.name, fromAppsemble ? 'appsemble' : deploymentName);
                 let entries = res.split('\n');
                 logger.silly(`Number of entries found for pod ${pod.metadata?.name}: ${entries.length}`);
-                entries = filterLogEntries([...entries], deploymentName, fromAppsemble);
-                podLogs.push({ fromAppsemble, entries });
+                entries = filterLogEntries([...entries], deploymentName, fromAppsemble ?? false);
+                podLogs.push({ fromAppsemble: fromAppsemble ?? false, entries });
             }
             catch (error) {
                 handleKubernetesError(error);

package/container/operations.js

@@ -41,7 +41,7 @@ export async function updateNamespacedSecret(secretName, value, appName, appId)
         existing.data[secretName] = Buffer.from(value).toString('base64');
         try {
             const { body: updatedSecret } = await coreApi.replaceNamespacedSecret(formattedName, namespace, existing);
-            logger.info(`Secret ${updatedSecret.metadata.name} updated successfully`);
+            logger.info(`Secret ${updatedSecret.metadata?.name} updated successfully`);
         }
         catch (error) {
             handleKubernetesError(error);
@@ -68,7 +68,7 @@ export async function deleteSecret(appName, appId, key) {
         try {
             const { body: secret } = await coreApi.readNamespacedSecret(secretName, namespace);
             logger.verbose(`Deleteing key ${key} of secret ${secretName} from namespace ${namespace} ...`);
-            if (!(key in secret.data)) {
+            if (!(secret.data && key in secret.data)) {
                 logger.warn(`Key ${key} does not exist on secret ${secret.metadata?.name}`);
                 return;
             }
@@ -113,17 +113,19 @@ export async function updateCompanionContainers(definitions, appName, appId, reg
     // Update or create deployment and service
     for (const def of definitions) {
         const serviceName = formatServiceName(def.name, appName, appId);
-        const existing = services?.items?.find((s) => s.metadata.name === serviceName);
+        const existing = services?.items?.find((s) => s.metadata?.name === serviceName);
         // Update
         if (existing) {
-            logger.verbose(`Updating resources for ${existing.metadata.name} in namespace ${namespace}`);
+            logger.verbose(`Updating resources for ${existing.metadata?.name} in namespace ${namespace}`);
             const patchOptions = [
-                existing.metadata?.name,
+                // @ts-expect-error 18048 variable is possibly undefined (strictNullChecks)
+                existing.metadata.name,
                 namespace,
                 [
                     {
                         op: 'replace',
                         path: '/metadata',
+                        // @ts-expect-error 18048 variable is possibly undefined (strictNullChecks)
                         value: { ...def.metadata, name: existing.metadata.name },
                     },
                     {
@@ -159,6 +161,7 @@ export async function updateCompanionContainers(definitions, appName, appId, reg
                 {
                     op: 'replace',
                     path: '/metadata',
+                    // @ts-expect-error 18048 variable is possibly undefined (strictNullChecks)
                     value: { ...def.metadata, name: existing.metadata.name },
                 },
                 {
@@ -169,7 +172,7 @@ export async function updateCompanionContainers(definitions, appName, appId, reg
                 {
                     op: 'replace',
                     path: '/spec/template/spec/containers/0/env',
-                    value: [...formatEnv(def.env, appName, appId)],
+                    value: [...formatEnv(def.env ?? [], appName, appId)],
                 },
                 {
                     op: 'add',
@@ -197,18 +200,19 @@ export async function updateCompanionContainers(definitions, appName, appId, reg
                     logger.silly(`Deployment ${serviceName} has 0 pods, skipping ...`);
                     continue;
                 }
-                const pod = body?.items?.find((i) => i.metadata.labels.app === existing.metadata.name);
+                const pod = body?.items?.find((i) => i.metadata?.labels?.app === existing.metadata?.name);
                 // Set base labels, such as selector, pod name, pod hash
                 const props = {
                     ...def.metadata,
                     labels: {
                         ...(def.metadata ? def.metadata.labels : null),
-                        app: pod.metadata.labels.app,
-                        'pod-template-hash': pod.metadata.labels['pod-template-hash'],
+                        app: pod?.metadata?.labels?.app,
+                        'pod-template-hash': pod?.metadata?.labels?.['pod-template-hash'],
                         appId,
                     },
-                    name: pod.metadata.name,
+                    name: pod?.metadata?.name,
                 };
+                // @ts-expect-error 2322 null is not assignable to type (strictNullChecks)
                 patchOptions[0] = pod?.metadata?.name;
                 patchOptions[2] = [
                     {
@@ -227,7 +231,9 @@ export async function updateCompanionContainers(definitions, appName, appId, reg
         // Create
         else {
             const { deployment, service } = generateDeploymentAndServiceSpecs(def, serviceName, appName, appId, registry);
-            if (isWhitelisted(deployment.spec.template.spec.containers[0].image)) {
+            // @ts-expect-error 2345 argument of type is not assignable to parameter of type
+            // (strictNullChecks)
+            if (isWhitelisted(deployment.spec?.template.spec?.containers[0].image)) {
                 logger.verbose(`Creating resources in namespace ${namespace} ...`);
                 try {
                     const deploymentObj = await appsApi.createNamespacedDeployment(namespace, deployment);
@@ -246,20 +252,22 @@ export async function updateCompanionContainers(definitions, appName, appId, reg
                 }
             }
             else {
-                logger.error(`Image ${deployment.spec.template.spec.containers[0].image} is not in the repository whitelist!`);
+                logger.error(`Image ${deployment.spec?.template.spec?.containers[0].image} is not in the repository whitelist!`);
             }
         }
     }
     // Delete companions removed from the definition
     for (const service of services.items) {
-        if (service.spec.type === 'ExternalName') {
+        if (service.spec?.type === 'ExternalName') {
             continue;
         }
         if (service.metadata?.labels &&
             appIdLabel in service.metadata.labels &&
             service.metadata.labels[appIdLabel] === appId) {
-            const existing = definitions.find((d) => formatServiceName(d.name, appName, appId) === service.metadata.name);
+            const existing = definitions.find((d) => formatServiceName(d.name, appName, appId) === service.metadata?.name);
             if (!existing) {
+                // @ts-expect-error 2345 argument of type is not assignable to parameter of type
+                // (strictNullChecks)
                 await deleteCompanionContainers(service.metadata?.name);
             }
         }

package/container/scale.js

@@ -30,9 +30,10 @@ export async function stopIdleContainers(interval = 10) {
         return;
     }
     for (const deployment of deployments.items) {
+        // @ts-expect-error 2339 Property does not exist on type undefined
         const { annotations, name, namespace } = deployment.metadata;
         if (deployment.metadata?.namespace !== getContainerNamespace() ||
-            deployment.spec.replicas === 0) {
+            deployment.spec?.replicas === 0) {
             continue;
         }
         const milliseconds = interval * 60 * 1000;
@@ -67,7 +68,7 @@ export async function stopIdleContainers(interval = 10) {
     }
 }
 export async function waitForPodReadiness(namespace, appSelector, maxWait = 10000) {
-    let isReady;
+    let isReady = false;
     const interval = 500;
     let elapsed = 0;
     const { coreApi } = getKubeConfig();

package/container/specs.js

@@ -18,7 +18,7 @@ export function generateDeploymentAndServiceSpecs(definition, name, appName, app
         image = `${registry.endsWith('/') ? registry.slice(0, -1) : registry}/${image}`;
     }
     const validatedResources = validateContainerResources(resources);
-    const env = formatEnv(definition.env, appName, appId);
+    const env = formatEnv(definition.env ?? [], appName, appId);
     // Env should have string keys!
     const podTemplateSpec = {
         metadata: {

package/fs.js

@@ -61,15 +61,19 @@ export async function readData(path) {
  * @returns The formatted content.
  */
 export async function writeData(path, data, { compare = compareStrings, sort = true } = {}) {
+    // @ts-expect-error 2769 No overload matches this call (strictNullChecks)
     const sorted = sort ? sortKeys(data, { deep: true, compare: compare || undefined }) : data;
     let buffer;
     try {
         const { default: prettier } = await import('prettier');
         const { inferredParser } = await prettier.getFileInfo(path, { resolveConfig: true });
         const prettierOptions = await prettier.resolveConfig(path, { editorconfig: true });
+        // @ts-expect-error 18048 variable is possibly null (strictNullChecks)
         prettierOptions.parser = inferredParser;
         buffer =
             inferredParser === 'yaml' ? stringify(sorted) : `${JSON.stringify(sorted, undefined, 2)}\n`;
+        // @ts-expect-error 2345 argument of type is not assignable to parameter of type
+        // (strictNullChecks)
         buffer = await prettier.format(buffer, prettierOptions);
     }
     catch {

package/getAppsembleMessages.js

@@ -17,6 +17,8 @@ export async function getAppsembleMessages(language, baseLanguage) {
     const baseLang = baseLanguage?.toLowerCase();
     const languages = await getSupportedLanguages();
     const messages = {};
+    // @ts-expect-error 2345 argument of type is not assignable to parameter of type
+    // (strictNullChecks)
     if (baseLang && languages.has(baseLanguage)) {
         Object.assign(messages, JSON.parse(await readFile(new URL(`${baseLang}.json`, translationsDir), 'utf8')));
     }

package/getMessagesUtil.js

@@ -1,7 +1,7 @@
 import { getAppsembleMessages, mergeMessages, } from '@appsemble/node-utils';
 import { defaultLocale, extractAppMessages, normalizeBlockName, } from '@appsemble/utils';
 import tags from 'language-tags';
-import { assertKoaError, throwKoaError } from './koa.js';
+import { assertKoaCondition, throwKoaError } from './koa.js';
 export async function getMessagesUtil(ctx, language, appId, merge, { getApp, getAppMessages, getBlockMessages }, override = 'true') {
     if (!tags.check(language)) {
         throwKoaError(ctx, 400, '`Language “${language}” is invalid`');
@@ -12,7 +12,7 @@ export async function getMessagesUtil(ctx, language, appId, merge, { getApp, get
         .find((sub) => sub.type() === 'language');
     const baseLang = baseLanguage && String(baseLanguage).toLowerCase();
     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 blockPrefixes = [];
     const blockQuery = [];
     const appMessages = await getAppMessages({ context: ctx, app, language });
@@ -27,13 +27,14 @@ export async function getMessagesUtil(ctx, language, appId, merge, { getApp, get
             blockPrefixes.push([blockName, prefix]);
         }),
     };
+    // @ts-expect-error 2322 null is not assignable to type (strictNullChecks)
     const blockMessages = await getBlockMessages({ context: ctx, blockQuery, baseLang, lang });
     if ((!appMessages.length || (merge && !appMessages.some((m) => m.language === lang))) &&
         lang !== (app.definition.defaultLanguage || defaultLocale)) {
         throwKoaError(ctx, 404, `Language “${language}” could not be found`);
     }
-    const baseLanguageMessages = override === 'true' && appMessages.find((m) => m.language === baseLang);
-    const languageMessages = override === 'true' && appMessages.find((m) => m.language === lang);
+    const baseLanguageMessages = override === 'true' ? appMessages.find((m) => m.language === baseLang) : undefined;
+    const languageMessages = override === 'true' ? appMessages.find((m) => m.language === lang) : undefined;
     for (const block of blockMessages) {
         const { name } = block;
         const defaultMessages = block.messages?.[defaultLocale];

package/getValidTrainings.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Returns all the directory names that are specified in the
+ * 'trainingOrder' of the chapters' `properties.json`
+ *
+ * @param path The absolute path to read the trainings from
+ * @returns List of the directory names that contain valid trainings
+ */
+export declare function getValidTrainings(path: string): Promise<string[]>;

package/getValidTrainings.js

@@ -0,0 +1,47 @@
+import { readdir, readFile } from 'node:fs/promises';
+import { logger } from './logger.js';
+/**
+ * Returns all the directory names that are specified in the
+ * 'trainingOrder' of the chapters' `properties.json`
+ *
+ * @param path The absolute path to read the trainings from
+ * @returns List of the directory names that contain valid trainings
+ */
+export async function getValidTrainings(path) {
+    const chapters = await readdir(path);
+    const trainingIds = [];
+    for (const chapterDirectory of chapters) {
+        let properties;
+        try {
+            properties = JSON.parse(await readFile(`${path}/${chapterDirectory}/properties.json`, 'utf8'));
+        }
+        catch {
+            logger.error(`Chapter directory "${chapterDirectory}" is missing a 'properties.json' file`);
+            continue;
+        }
+        const missingProperties = ['blockedBy', 'title', 'trainingOrder'].filter((prop) => !Object.prototype.hasOwnProperty.call(properties, prop));
+        if (missingProperties.length > 0) {
+            logger.error(`Missing properties [${missingProperties}] in "properties.json"`);
+            continue;
+        }
+        for (const trainingDirectory of properties.trainingOrder) {
+            try {
+                await readdir(`${path}/${chapterDirectory}/${trainingDirectory}`);
+            }
+            catch {
+                logger.error(`Could not find "${trainingDirectory}"`);
+                continue;
+            }
+            try {
+                await readFile(`${path}/${chapterDirectory}/${trainingDirectory}/index.md`);
+            }
+            catch {
+                logger.error(`Training "${trainingDirectory}" is missing an index.md`);
+                continue;
+            }
+            trainingIds.push(trainingDirectory);
+        }
+    }
+    return trainingIds;
+}
+//# sourceMappingURL=getValidTrainings.js.map

package/icon.js

@@ -16,6 +16,7 @@ export async function serveIcon(ctx, { background, cache, fallback, height, icon
     if (raw) {
         const { format } = await img.metadata();
         ctx.body = buffer;
+        // @ts-expect-error 2322 null is not assignable to type (strictNullChecks)
         ctx.type = format;
         return;
     }
@@ -41,8 +42,10 @@ export async function serveIcon(ctx, { background, cache, fallback, height, icon
         // Make the regular icon maskable
         const actual = img;
         const metadata = await actual.metadata();
+        // @ts-expect-error 18048 variable is possibly undefined (strictNullChecks)
         const angle = Math.atan(metadata.height / metadata.width);
         actual.resize({
+            // @ts-expect-error 18048 variable is possibly undefined (strictNullChecks)
             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.
@@ -50,7 +53,9 @@ export async function serveIcon(ctx, { background, cache, fallback, height, icon
             fit: 'contain',
             background,
         });
+        // @ts-expect-error 18048 variable is possibly undefined (strictNullChecks)
         img = sharp(Buffer.alloc(width * height * 4, 0), {
+            // @ts-expect-error 2322 null is not assignable to type (strictNullChecks)
             raw: { width, height, channels: 4 },
         });
         img.resize({ width, height });

package/index.d.ts

@@ -30,10 +30,14 @@ export * from './server/routes/appRouter/iconHandler.js';
 export * from './server/controllers/index.js';
 export * from './server/types.js';
 export * from './koa.js';
-export { bulmaVersion, faVersion, version } from './versions.cjs';
+export { bulmaVersion, faVersion, version } from './versions.js';
 export * from './EmailQuotaExceededError.js';
 export * from './EmailError.js';
 export * from './AppMemberPropertiesError.js';
 export * from './authentication.js';
 export * from './getMessagesUtil.js';
 export * from './container/index.js';
+export * from './s3.js';
+export * from './uploads.js';
+export * from './assets.js';
+export * from './getValidTrainings.js';

package/index.js

@@ -30,11 +30,15 @@ export * from './server/routes/appRouter/iconHandler.js';
 export * from './server/controllers/index.js';
 export * from './server/types.js';
 export * from './koa.js';
-export { bulmaVersion, faVersion, version } from './versions.cjs';
+export { bulmaVersion, faVersion, version } from './versions.js';
 export * from './EmailQuotaExceededError.js';
 export * from './EmailError.js';
 export * from './AppMemberPropertiesError.js';
 export * from './authentication.js';
 export * from './getMessagesUtil.js';
 export * from './container/index.js';
+export * from './s3.js';
+export * from './uploads.js';
+export * from './assets.js';
+export * from './getValidTrainings.js';
 //# sourceMappingURL=index.js.map

package/interceptors.js

@@ -27,7 +27,7 @@ export function formData(config) {
  */
 export function requestLogger(config) {
     const time = Date.now();
-    logger.verbose(`> ${time} ${highlight(`${config.method.toUpperCase()} ${axios.getUri(config)} HTTP/1.1`, {
+    logger.verbose(`> ${time} ${highlight(`${config.method?.toUpperCase()} ${axios.getUri(config)} HTTP/1.1`, {
         language: 'http',
     })}`);
     // eslint-disable-next-line no-param-reassign

package/koa.d.ts

@@ -56,7 +56,7 @@ type HttpErrorCodes = keyof typeof errorStatusMap;
  * @param message The message for in the response body.
  * @param data Optional data to include.
  */
-export declare function throwKoaError(ctx: Context, status: HttpErrorCodes, message?: string, data?: Record<string, any>): void;
+export declare function throwKoaError(ctx: Context, status: HttpErrorCodes, message?: string, data?: Record<string, any>): never;
 /**
  * Throw standard Koa error response when condition is met.
  *
@@ -67,3 +67,15 @@ export declare function throwKoaError(ctx: Context, status: HttpErrorCodes, mess
  * @param data Optional data to include.
  */
 export declare function assertKoaError(condition: boolean, ctx: Context, status: HttpErrorCodes, message?: string, data?: Record<string, any>): void;
+/**
+ * Throws standard Koa error response when condition is _not_ met.
+ * Does the opposite of `assertKoaError`.
+ *
+ * @param condition The condition to check.
+ * @param ctx The Koa context used to throw the error response.
+ * @param status The HTTP status code to use.
+ * @param message The message for in the response body.
+ * @param data Optional data to include.
+ * @see throwKoaError
+ */
+export declare function assertKoaCondition(condition: boolean, ctx: Context, status: HttpErrorCodes, message?: string, data?: Record<string, any>): asserts condition;

package/koa.js

@@ -1,11 +1,12 @@
 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';
+import { csvParser, streamParser, xWwwFormUrlencodedParser } from './parsers.js';
 function serializer() {
     return koaSerializer({
         serializers: {
             'application/scim+json': (body) => JSON.stringify(body),
+            // @ts-expect-error 2322 unknown is not assignable to type string (strictNullChecks)
             'application/xml': (body) => body,
             'text/csv': convertToCsv,
         },
@@ -17,6 +18,7 @@ function bodyParser() {
             'application/scim+json': jsonParser,
             'application/x-www-form-urlencoded': xWwwFormUrlencodedParser,
             'text/csv': csvParser,
+            'multipart/form-data': streamParser,
             '*/*': bufferParser,
         },
     });
@@ -98,4 +100,18 @@ export function assertKoaError(condition, ctx, status, message, data) {
         throwKoaError(ctx, status, message, data);
     }
 }
+/**
+ * Throws standard Koa error response when condition is _not_ met.
+ * Does the opposite of `assertKoaError`.
+ *
+ * @param condition The condition to check.
+ * @param ctx The Koa context used to throw the error response.
+ * @param status The HTTP status code to use.
+ * @param message The message for in the response body.
+ * @param data Optional data to include.
+ * @see throwKoaError
+ */
+export function assertKoaCondition(condition, ctx, status, message, data) {
+    assertKoaError(!condition, ctx, status, message, data);
+}
 //# sourceMappingURL=koa.js.map

package/logger.js

@@ -15,8 +15,8 @@ function httpErrorToString(error) {
     return [
         chalk.blue.bold('Request:'),
         highlight([
-            `${config.method.toUpperCase()} ${axios.getUri(config)} HTTP/${request?.res?.httpVersion ?? '1.1'}`,
-            ...Object.entries(config.headers)
+            `${config?.method?.toUpperCase()} ${axios.getUri(config)} HTTP/${request?.res?.httpVersion ?? '1.1'}`,
+            ...Object.entries(config?.headers ?? {})
                 .map(([key, value]) => [headerCase(key), value])
                 .map(([key, value]) => `${key}: ${key === 'Authorization' ? 'xxxxxxxxxx' : value}`)
                 .sort(),
@@ -40,11 +40,13 @@ function httpErrorToString(error) {
 function toString(info) {
     if (info instanceof Error) {
         if ('sql' in info) {
-            return info.stack.replace(/^Error/, `${info.sql}\n${info.name}: ${info.message}`);
+            // @ts-expect-error 2322 null is not assignable to type (strictNullChecks)
+            return info.stack?.replace(/^Error/, `${info.sql}\n${info.name}: ${info.message}`);
         }
         if (axios.isAxiosError(info)) {
             return httpErrorToString(info);
         }
+        // @ts-expect-error 2322 null is not assignable to type (strictNullChecks)
         return info.stack;
     }
     if (typeof info.message === 'string') {