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

package/server/controllers/common/apps/resources/createCreateAppResourceController.js

@@ -1,6 +1,6 @@
 import { randomUUID } from 'node:crypto';
 import { isDeepStrictEqual } from 'node:util';
-import { getResourceDefinition, processResourceBody } from '../../../../../index.js';
+import { getResourceDefinition, processResourceBody, uploadAssets, } from '../../../../../index.js';
 /**
  * Create a controller for resource creation.
  *
@@ -26,12 +26,16 @@ export function createCreateAppResourceController(options) {
         });
         const resourceDefinition = getResourceDefinition(app.definition, resourceType, ctx);
         const appAssets = await getAppAssets({ app, context: ctx });
-        const [processedBody, preparedAssets] = processResourceBody(ctx, resourceDefinition, undefined, undefined, appAssets.map((appAsset) => ({ id: appAsset.id, name: appAsset.name })));
+        const [processedBody, preparedAssets] = processResourceBody(ctx, resourceDefinition, undefined, undefined, 
+        // @ts-expect-error 2345 argument of type is not assignable to parameter of type
+        // (strictNullChecks)
+        appAssets.map((appAsset) => ({ id: appAsset.id, name: appAsset.name })));
         if (Array.isArray(processedBody) && !processedBody.length) {
             ctx.body = [];
             return;
         }
         const resources = Array.isArray(processedBody) ? processedBody : [processedBody];
+        const assetsToUpload = [];
         if (!(ctx.client && 'app' in ctx.client) && query?.seed === 'true') {
             const preparedSeedAssets = structuredClone(preparedAssets);
             const preparedSeedResources = resources.map((resource) => {
@@ -49,6 +53,7 @@ export function createCreateAppResourceController(options) {
             });
             for (const preparedSeedAsset of preparedSeedAssets) {
                 const index = resources.findIndex(({ $clonable: clonable, $ephemeral: ephemeral, $seed: unused, ...cleanResource }) => {
+                    // @ts-expect-error Messed up
                     const { $clonable, $ephemeral, $seed, ...cleanAssetResource } = preparedSeedAsset.resource;
                     return isDeepStrictEqual(cleanResource, cleanAssetResource);
                 });
@@ -67,11 +72,16 @@ export function createCreateAppResourceController(options) {
                 preparedAssets: preparedSeedAssets,
                 resourceType,
                 options,
+                positioning: resourceDefinition.positioning,
             });
             if (!app.demoMode) {
                 ctx.body = Array.isArray(processedBody) ? createdSeedResources : createdSeedResources[0];
+                // @ts-expect-error 2345 argument of type is not assignable to parameter of type
+                // (strictNullChecks)
+                await uploadAssets(app.id, preparedSeedAssets);
                 return;
             }
+            assetsToUpload.push(...preparedSeedAssets);
         }
         const createdResources = await createAppResourcesWithAssets({
             app,
@@ -87,6 +97,10 @@ export function createCreateAppResourceController(options) {
             resourceType,
             options,
         });
+        assetsToUpload.push(...preparedAssets);
+        // @ts-expect-error 2345 argument of type is not assignable to parameter of type
+        // (strictNullChecks)
+        await uploadAssets(app.id, assetsToUpload);
         ctx.body = Array.isArray(processedBody) ? createdResources : createdResources[0];
     };
 }

package/server/controllers/common/apps/resources/createDeleteAppResourceController.js

@@ -1,4 +1,4 @@
-import { assertKoaError } from '@appsemble/node-utils';
+import { assertKoaCondition } from '@appsemble/node-utils';
 export function createDeleteAppResourceController(options) {
     return async (ctx) => {
         const { pathParams: { appId, resourceId, resourceType }, queryParams: { selectedGroupId }, user: authSubject, } = ctx;
@@ -21,7 +21,7 @@ export function createDeleteAppResourceController(options) {
             context: ctx,
             findOptions,
         });
-        assertKoaError(!resource, ctx, 404, 'Resource not found');
+        assertKoaCondition(resource != null, ctx, 404, 'Resource not found');
         await checkAppPermissions({
             context: ctx,
             permissions: [

package/server/controllers/common/apps/resources/createGetAppResourceByIdController.js

@@ -1,4 +1,4 @@
-import { assertKoaError, getRemapperContext, getResourceDefinition, } from '@appsemble/node-utils';
+import { assertKoaCondition, getRemapperContext, getResourceDefinition, } from '@appsemble/node-utils';
 import { defaultLocale, remap } from '@appsemble/utils';
 export function createGetAppResourceByIdController(options) {
     return async (ctx) => {
@@ -22,7 +22,7 @@ export function createGetAppResourceByIdController(options) {
             context: ctx,
             findOptions,
         });
-        assertKoaError(!resource, ctx, 404, 'Resource not found');
+        assertKoaCondition(resource != null, ctx, 404, 'Resource not found');
         await checkAppPermissions({
             context: ctx,
             permissions: [
@@ -38,7 +38,7 @@ export function createGetAppResourceByIdController(options) {
         if (view) {
             const context = await getRemapperContext(app, app.definition.defaultLanguage || defaultLocale, options, ctx);
             const resourceDefinition = getResourceDefinition(app.definition, resourceType, ctx, view);
-            ctx.body = remap(resourceDefinition.views[view].remap, resource, context);
+            ctx.body = remap(resourceDefinition.views?.[view].remap ?? null, resource, context);
             return;
         }
         ctx.body = resource;

package/server/controllers/common/apps/resources/createQueryAppResourcesController.js

@@ -48,7 +48,7 @@ export function createQueryAppResourcesController(options) {
         });
         if (view) {
             const context = await getRemapperContext(app, app.definition.defaultLanguage || defaultLocale, options, ctx);
-            ctx.body = resources.map((resource) => remap(resourceDefinition.views[view].remap, resource, context));
+            ctx.body = resources.map((resource) => remap(resourceDefinition.views?.[view].remap ?? null, resource, context));
             return;
         }
         ctx.body = resources;

package/server/controllers/common/apps/resources/createUpdateAppResourceController.js

@@ -1,4 +1,4 @@
-import { assertKoaError, getResourceDefinition, processResourceBody, } from '@appsemble/node-utils';
+import { assertKoaCondition, getResourceDefinition, processResourceBody, } from '@appsemble/node-utils';
 export function createUpdateAppResourceController(options) {
     return async (ctx) => {
         const { pathParams: { appId, resourceId, resourceType }, queryParams: { selectedGroupId }, user: authSubject, } = ctx;
@@ -21,7 +21,7 @@ export function createUpdateAppResourceController(options) {
             context: ctx,
             findOptions,
         });
-        assertKoaError(!oldResource, ctx, 404, 'Resource not found');
+        assertKoaCondition(oldResource != null, ctx, 404, 'Resource not found');
         await checkAppPermissions({
             context: ctx,
             permissions: [
@@ -34,7 +34,10 @@ export function createUpdateAppResourceController(options) {
         });
         const appAssets = await getAppAssets({ context: ctx, app });
         const resourceDefinition = getResourceDefinition(app.definition, resourceType, ctx);
-        const [processedBody, preparedAssets, deletedAssetIds] = processResourceBody(ctx, resourceDefinition, appAssets.filter((asset) => asset.resourceId === resourceId).map((asset) => asset.id), oldResource.expires, appAssets.map((asset) => ({ id: asset.id, name: asset.name })));
+        const [processedBody, preparedAssets, deletedAssetIds] = processResourceBody(ctx, resourceDefinition, appAssets.filter((asset) => asset.resourceId === resourceId).map((asset) => asset.id), oldResource.expires, 
+        // @ts-expect-error 2345 argument of type is not assignable to parameter of type
+        // (strictNullChecks)
+        appAssets.map((asset) => ({ id: asset.id, name: asset.name })));
         const resources = Array.isArray(processedBody) ? processedBody : [processedBody];
         ctx.body = await updateAppResource({
             app,

package/server/controllers/common/apps/variables/createGetAppVariablesController.js

@@ -1,9 +1,9 @@
-import { assertKoaError } from '../../../../../koa.js';
+import { assertKoaCondition } from '../../../../../koa.js';
 export function createGetAppVariablesController({ getApp, getAppVariables }) {
     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');
         ctx.body = await getAppVariables({
             context: ctx,
             app,

package/server/controllers/main/apps/assets/createCreateAppAssetController.js

@@ -1,13 +1,13 @@
-import { assertKoaError } from '../../../../../koa.js';
+import { assertKoaCondition } from '../../../../../koa.js';
 export function createCreateAppAssetController({ createAppAsset, getApp }) {
     return async (ctx) => {
-        const { pathParams: { appId }, request: { body: { file: { contents, filename, mime }, name, }, }, } = ctx;
+        const { pathParams: { appId }, request: { body: { file: { filename, mime, path }, name, }, }, } = 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 createAppAsset({
             app,
             context: ctx,
-            payload: { filename, mime, name, data: contents },
+            payload: { filename, mime, name, path },
         });
         ctx.status = 201;
         ctx.body = { id: asset.id, mime, filename, name };

package/server/controllers/main/apps/resources/createDeleteAppSeedResourcesController.js

@@ -1,11 +1,11 @@
-import { assertKoaError } from '../../../../../koa.js';
+import { assertKoaCondition } from '../../../../../koa.js';
 import { deleteResourcesRecursively } from '../../../../utils/resources.js';
 export function createDeleteAppSeedResourcesController(options) {
     return async (ctx) => {
         const { pathParams: { appId }, } = ctx;
         const { getApp } = options;
         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');
         for (const resourceType of Object.keys(app.definition.resources ?? {})) {
             await deleteResourcesRecursively(resourceType, app, options, ctx);
         }

package/server/routes/appRouter/blockAssetHandler.js

@@ -1,9 +1,11 @@
-import { assertKoaError } from '@appsemble/node-utils';
+import { assertKoaCondition } from '@appsemble/node-utils';
 export function createBlockAssetHandler({ getBlockAsset }) {
     return async (ctx) => {
-        const { params: { filename, name, version }, } = ctx;
+        const { 
+        // @ts-expect-error Messed up
+        params: { filename, name, version }, } = ctx;
         const blockAsset = await getBlockAsset({ filename, name, version, context: ctx });
-        assertKoaError(!blockAsset, ctx, 404, 'Block asset not found');
+        assertKoaCondition(blockAsset != null, ctx, 404, 'Block asset not found');
         ctx.body = blockAsset.content;
         ctx.type = blockAsset.mime;
     };

package/server/routes/appRouter/blockCssHandler.js

@@ -1,9 +1,11 @@
-import { assertKoaError } from '@appsemble/node-utils';
+import { assertKoaCondition } from '@appsemble/node-utils';
 export function createBlockCssHandler({ getApp, getAppBlockStyles }) {
     return async (ctx) => {
-        const { params: { name }, } = ctx;
+        const { 
+        // @ts-expect-error Messed up
+        params: { name }, } = ctx;
         const app = await getApp({ context: ctx });
-        assertKoaError(!app, ctx, 404, 'App not found');
+        assertKoaCondition(app != null, ctx, 404, 'App not found');
         const appBlockStyles = await getAppBlockStyles({ app, name, context: ctx });
         const [style] = appBlockStyles;
         ctx.body = style ? style.style : '';

package/server/routes/appRouter/bulmaHandler.js

@@ -85,6 +85,7 @@ export function createBulmaHandler({ createTheme, getTheme }) {
             themeColor: (getQueryParameter(query.themeColor) || baseTheme.themeColor).toLowerCase(),
             splashColor: (getQueryParameter(query.splashColor) || baseTheme.splashColor).toLowerCase(),
             fontFamily: getQueryParameter(query.fontFamily) || baseTheme.font.family,
+            // @ts-expect-error 2322 null is not assignable to type (strictNullChecks)
             fontSource: getQueryParameter(query.fontSource) || baseTheme.font.source,
         };
         const result = await getTheme({ theme });

package/server/routes/appRouter/cssHandler.js

@@ -1,8 +1,8 @@
-import { assertKoaError } from '@appsemble/node-utils';
+import { assertKoaCondition } from '@appsemble/node-utils';
 export function createCssHandler(type, { getAppStyles }) {
     return async (ctx) => {
         const app = await getAppStyles({ context: ctx, query: { attributes: [type], raw: true } });
-        assertKoaError(!app, ctx, 404, 'App not found');
+        assertKoaCondition(app != null, ctx, 404, 'App not found');
         ctx.body = app[type];
         ctx.type = 'css';
     };

package/server/routes/appRouter/iconHandler.js

@@ -2,7 +2,9 @@ import { serveIcon } from '@appsemble/node-utils';
 import { isEqual, parseISO } from 'date-fns';
 export function createIconHandler({ getApp, getAppIcon, getDbUpdated }) {
     return async (ctx) => {
-        const { params: { size = 128 }, query: { maskable = false, updated }, } = ctx;
+        const { 
+        // @ts-expect-error Messed up
+        params: { size = 128 }, query: { maskable = false, updated }, } = ctx;
         const app = await getApp({
             context: ctx,
             query: { where: { ...(updated ? { updated } : {}) } },
@@ -14,6 +16,7 @@ export function createIconHandler({ getApp, getAppIcon, getDbUpdated }) {
             cache: dbUpdated ? isEqual(parseISO(updated), dbUpdated) : false,
             fallback: 'mobile-alt-solid.png',
             height: size && Number.parseInt(size),
+            // @ts-expect-error 2322 null is not assignable to type (strictNullChecks)
             icon: appIcon,
             maskable: Boolean(maskable),
             width: size && Number.parseInt(size),

package/server/routes/appRouter/indexHandler.js

@@ -2,7 +2,7 @@ import { randomBytes } from 'node:crypto';
 import { createThemeURL, defaultLocale, getAppBlocks, mergeThemes } from '@appsemble/utils';
 import { organizationBlocklist } from '../../../organizationBlocklist.js';
 import { makeCSP, render } from '../../../render.js';
-import { bulmaVersion, faVersion } from '../../../versions.cjs';
+import { bulmaVersion, faVersion } from '../../../versions.js';
 export const bulmaURL = `/bulma/${bulmaVersion}/bulma.min.css`;
 export const faURL = `/fa/${faVersion}/css/all.min.css`;
 export function createIndexHandler({ createSettings, getApp, getAppDetails, getAppMessages, getAppUrl, getCsp, getHost, }) {
@@ -56,6 +56,8 @@ export function createIndexHandler({ createSettings, getApp, getAppDetails, getA
             host,
             locale: defaultLanguage,
             locales: languages.filter((lang) => lang !== defaultLanguage),
+            // @ts-expect-error 2345 argument of type is not assignable to parameter of type
+            // (strictNullChecks)
             bulmaURL: createThemeURL(mergeThemes(app.definition.theme)),
             faURL,
             nonce,

package/server/routes/appRouter/manifestHandler.js

@@ -1,11 +1,11 @@
-import { assertKoaError } from '@appsemble/node-utils';
+import { assertKoaCondition } from '@appsemble/node-utils';
 import { baseTheme, normalize } from '@appsemble/utils';
 import { extension } from 'mime-types';
 const iconSizes = [48, 144, 192, 512];
 export function createManifestHandler({ getApp, getAppScreenshots }) {
     return async (ctx) => {
         const app = await getApp({ context: ctx });
-        assertKoaError(!app, ctx, 404, 'Block asset not found');
+        assertKoaCondition(app != null, ctx, 404, 'Block asset not found');
         const { defaultPage, description, name, theme = baseTheme } = app.definition;
         const { themeColor = '#ffffff', splashColor = themeColor } = theme;
         const appScreenshots = await getAppScreenshots({ app, context: ctx });

package/server/routes/appRouter/readmeHandler.js

@@ -1,12 +1,13 @@
-import { assertKoaError } from '@appsemble/node-utils';
+import { assertKoaCondition } from '@appsemble/node-utils';
 export function createReadmeHandler({ getApp, getAppReadmes }) {
     return async (ctx) => {
+        // @ts-expect-error Messed up
         const { id } = ctx.params;
         const app = await getApp({ context: ctx });
-        assertKoaError(!app, ctx, 404, 'App not found');
+        assertKoaCondition(app != null, ctx, 404, 'App not found');
         const appReadmes = await getAppReadmes({ app, context: ctx });
         const appReadme = appReadmes.find((readme) => readme.id === Number.parseInt(id));
-        assertKoaError(!appReadme, ctx, 404, 'Readme not found');
+        assertKoaCondition(appReadme != null, ctx, 404, 'Readme not found');
         const { file } = appReadme;
         ctx.type = 'text/markdown';
         ctx.body = file;

package/server/routes/appRouter/robotsHandler.js

@@ -1,8 +1,8 @@
-import { assertKoaError, logger } from '@appsemble/node-utils';
+import { assertKoaCondition, logger } from '@appsemble/node-utils';
 export function createRobotsHandler({ getApp }) {
     return async (ctx) => {
         const app = await getApp({ context: ctx });
-        assertKoaError(!app, ctx, 404, 'App not found');
+        assertKoaCondition(app != null, ctx, 404, 'App not found');
         switch (app.visibility) {
             case 'public':
                 ctx.body = 'User-agent: *\nAllow: *\n';

package/server/routes/appRouter/screenshotHandler.js

@@ -1,12 +1,13 @@
-import { assertKoaError } from '@appsemble/node-utils';
+import { assertKoaCondition } from '@appsemble/node-utils';
 export function createScreenshotHandler({ getApp, getAppScreenshots }) {
     return async (ctx) => {
+        // @ts-expect-error Messed up
         const { id } = ctx.params;
         const app = await getApp({ context: ctx });
-        assertKoaError(!app, ctx, 404, 'App not found');
+        assertKoaCondition(app != null, ctx, 404, 'App not found');
         const appScreenshots = await getAppScreenshots({ app, context: ctx });
         const appScreenshot = appScreenshots.find((screenshot) => screenshot.id === Number.parseInt(id));
-        assertKoaError(!appScreenshot, ctx, 404, 'Screenshot not found');
+        assertKoaCondition(appScreenshot != null, ctx, 404, 'Screenshot not found');
         const { mime, screenshot } = appScreenshot;
         ctx.type = mime;
         ctx.body = screenshot;

package/server/routes/appRouter/serviceWorkerHandler.js

@@ -1,5 +1,5 @@
 import { readFile } from 'node:fs/promises';
-import { assertKoaError } from '@appsemble/node-utils';
+import { assertKoaCondition } from '@appsemble/node-utils';
 import { getAppBlocks } from '@appsemble/utils';
 export function createServiceWorkerHandler({ getApp, getBlocksAssetsPaths }) {
     return async (ctx) => {
@@ -9,7 +9,7 @@ export function createServiceWorkerHandler({ getApp, getBlocksAssetsPaths }) {
             ? readFile(new URL('../../../../../dist/app/service-worker.js', import.meta.url), 'utf8')
             : ctx.fs.promises.readFile(filename, 'utf8'));
         const app = await getApp({ context: ctx });
-        assertKoaError(!app, ctx, 404, 'App does not exist.');
+        assertKoaCondition(app != null, ctx, 404, 'App does not exist.');
         const identifiableBlocks = getAppBlocks(app.definition);
         const blocksAssetsPaths = await getBlocksAssetsPaths({ identifiableBlocks, context: ctx });
         ctx.body = `const blockAssets=${JSON.stringify(blocksAssetsPaths)};${serviceWorker}`;

package/server/types.d.ts

@@ -1,3 +1,4 @@
+import { type Readable } from 'node:stream';
 import { type App, type AppConfigEntry, type AppMemberInfo, type AppMessages, type Asset, type BlockDefinition, type BlockManifest, type ControllerDefinition, type CustomAppPermission, type EmailActionDefinition, type Group, type OrganizationPermission, type Resource, type ResourceDefinition, type Theme as ThemeType } from '@appsemble/types';
 import { type IdentifiableBlock } from '@appsemble/utils';
 import { type RawAxiosRequestConfig } from 'axios';
@@ -36,6 +37,7 @@ declare module 'koas-security' {
             scope: string;
         };
         studio: {};
+        webhook: {};
     }
     interface Users {
         app: AuthSubject;
@@ -43,6 +45,7 @@ declare module 'koas-security' {
         cli: AuthSubject;
         scim: AuthSubject;
         studio: AuthSubject;
+        webhook: AuthSubject;
     }
 }
 declare module 'koas-parameters' {
@@ -77,9 +80,10 @@ declare module 'koas-parameters' {
         appVariableId: number;
         userId: string;
         memberEmail: string;
-        trainingBlockId: number;
         trainingId: number;
         container: string;
+        webhookName: string;
+        webhookSecretId: string;
     }
     interface QueryParams {
         domains: string[];
@@ -256,7 +260,7 @@ export interface GetAppResourcesParams extends GetAppSubEntityParams {
     type: string;
 }
 export interface PreparedAsset extends Pick<Asset, 'filename' | 'id' | 'mime'> {
-    data: Buffer;
+    path: string;
     resource?: Record<string, unknown>;
 }
 export interface CreateAppResourcesWithAssetsParams extends GetAppSubEntityParams {
@@ -265,6 +269,7 @@ export interface CreateAppResourcesWithAssetsParams extends GetAppSubEntityParam
     resourceType: string;
     options: Options;
     groupId?: number;
+    positioning?: boolean;
 }
 export interface UpdateAppResourceParams extends GetAppSubEntityParams {
     id: number | string;
@@ -286,7 +291,7 @@ export interface CreateAppAssetParams extends GetAppSubEntityParams {
         filename: string;
         mime: string;
         name: string;
-        data: Buffer;
+        path: string;
     };
     seed?: boolean;
 }
@@ -330,7 +335,7 @@ export interface AppBlockStyle {
     style: string;
 }
 export interface AppAsset extends Asset {
-    data: Buffer;
+    stream: Readable;
 }
 export interface ProjectAsset {
     filename: string;
@@ -349,8 +354,8 @@ export interface ParsedQuery {
 }
 export type ContentSecurityPolicy = Record<string, (string | false)[]>;
 export interface Options {
-    getCurrentAppMember: (params: GetCurrentAppMemberParams) => Promise<AppMemberInfo>;
-    getCurrentAppMemberGroups: (params: GetCurrentAppMemberGroupsParams) => Promise<Group[]>;
+    getCurrentAppMember: (params: GetCurrentAppMemberParams) => Promise<AppMemberInfo | null>;
+    getCurrentAppMemberGroups: (params: GetCurrentAppMemberGroupsParams) => Promise<Group[] | null>;
     getApp: (params: GetAppParams) => Promise<App>;
     getAppDetails: (params: GetAppParams) => Promise<AppDetails>;
     getAppMessages: (params: GetAppMessagesParams) => Promise<AppMessages[]>;
@@ -377,7 +382,7 @@ export interface Options {
     checkAppPermissions: (params: CheckAppPermissionsParams) => Promise<void>;
     reloadUser: (params: ReloadUserParams) => Promise<Record<string, any>>;
     parseQuery: (params: ParseQueryParams) => ParsedQuery;
-    getAppResource: (params: GetAppResourceParams) => Promise<Resource>;
+    getAppResource: (params: GetAppResourceParams) => Promise<Resource | null>;
     getAppResources: (params: GetAppResourcesParams) => Promise<Resource[]>;
     createAppResourcesWithAssets: (params: CreateAppResourcesWithAssetsParams) => Promise<Resource[]>;
     updateAppResource: (params: UpdateAppResourceParams) => Promise<Resource | null>;
@@ -390,4 +395,14 @@ export interface Options {
     sendNotifications: (params: SendNotificationsParams) => Promise<void>;
     getAppVariables: (params: GetAppVariablesParams) => Promise<AppConfigEntry[]>;
 }
+export declare class TempFile {
+    readonly filename: string;
+    readonly mime: string;
+    readonly path: string;
+    constructor({ filename, mime, path }: {
+        filename: string;
+        mime: string;
+        path: string;
+    });
+}
 export {};

package/server/types.js

@@ -1,2 +1,8 @@
-export {};
+export class TempFile {
+    constructor({ filename, mime, path }) {
+        this.filename = filename;
+        this.mime = mime;
+        this.path = path;
+    }
+}
 //# sourceMappingURL=types.js.map

package/server/utils/actions.js

@@ -1,4 +1,4 @@
-import { assertKoaError, createFormData, EmailQuotaExceededError, getContainerNamespace, getRemapperContext, logger, parseServiceUrl, scaleDeployment, setLastRequestAnnotation, throwKoaError, version, waitForPodReadiness, } from '@appsemble/node-utils';
+import { assertKoaCondition, createFormData, EmailQuotaExceededError, getContainerNamespace, getRemapperContext, logger, parseServiceUrl, scaleDeployment, setLastRequestAnnotation, throwKoaError, version, waitForPodReadiness, } from '@appsemble/node-utils';
 import { defaultLocale, remap } from '@appsemble/utils';
 import axios from 'axios';
 import { get, mapValues, pick } from 'lodash-es';
@@ -82,7 +82,7 @@ async function handleRequestProxy(ctx, app, action, useBody, options) {
     // TODO
     const { applyAppServiceSecrets } = options;
     const remapperContext = await getRemapperContext(app, app.definition.defaultLanguage || defaultLocale, options, ctx);
-    const proxyUrl = new URL(String(remap(action.url, data, remapperContext)));
+    const proxyUrl = new URL(String(remap(action.url ?? null, data, remapperContext)));
     if (/\/api\/apps\/\d+\/actions\/.*/.test(proxyUrl.pathname) && ctx.URL.host === proxyUrl.host) {
         throwKoaError(ctx, 400, 'Not allowed to make direct requests to the Appsemble action controller using this action.');
     }
@@ -103,7 +103,8 @@ async function handleRequestProxy(ctx, app, action, useBody, options) {
         headers: {},
     };
     axiosConfig = await applyAppServiceSecrets({ axiosConfig, context: ctx, app });
-    if (axiosConfig.method.toUpperCase() !== method) {
+    axiosConfig.headers ?? (axiosConfig.headers = {});
+    if (axiosConfig.method?.toUpperCase() !== method) {
         throwKoaError(ctx, 400, 'Method does not match the request action method');
     }
     if (useBody) {
@@ -118,16 +119,18 @@ async function handleRequestProxy(ctx, app, action, useBody, options) {
     axiosConfig.validateStatus = () => true;
     axiosConfig.decompress = false;
     let response;
-    const urlPattern = /^http:\/\/(([\da-z-]+).){2}svc.cluster.local/;
+    const containerUrlPattern = /^http:\/\/(([\da-z-]+).){2}svc.cluster.local/;
     // Restricting access to only the containers defined by the app
-    if (urlPattern.test(String(proxyUrl))) {
-        axiosConfig.url = axiosConfig.url.replace(axiosConfig.url.split('.')[1], getContainerNamespace());
+    if (containerUrlPattern.test(String(proxyUrl))) {
+        axiosConfig.url = axiosConfig.url?.replace(axiosConfig.url.split('.')[1], getContainerNamespace());
         const { appId } = parseServiceUrl(String(proxyUrl));
         if (appId !== String(app.id)) {
             throwKoaError(ctx, 403, 'Forbidden');
         }
     }
     logger.verbose(`Forwarding request to ${axios.getUri(axiosConfig)}`);
+    logger.verbose('Axios Config:');
+    logger.verbose(axiosConfig);
     try {
         response = await axios(axiosConfig);
         logger.verbose(response);
@@ -135,15 +138,16 @@ async function handleRequestProxy(ctx, app, action, useBody, options) {
     catch (err) {
         // If request is sent to a companion container and fails
         // Try to start it anew and retry the request
-        if (urlPattern.test(String(proxyUrl))) {
+        if (containerUrlPattern.test(String(proxyUrl))) {
             const { deploymentName, namespace } = parseServiceUrl(String(proxyUrl));
             try {
                 await scaleDeployment(namespace, deploymentName, 1);
-                await waitForPodReadiness(namespace, deploymentName, process.env.POD_READINESS_TIMEOUT ?? undefined);
+                await waitForPodReadiness(namespace, deploymentName, Number.isNaN(Number(process.env.POD_READINESS_TIMEOUT))
+                    ? undefined
+                    : Number(process.env.POD_READINESS_TIMEOUT));
                 response = await axios(axiosConfig);
             }
             catch {
-                logger.error(err);
                 throwKoaError(ctx, 502, 'Bad Gateway');
             }
             finally {
@@ -152,6 +156,8 @@ async function handleRequestProxy(ctx, app, action, useBody, options) {
         }
         else {
             logger.error(err);
+            logger.verbose('Response:');
+            logger.verbose(response);
             throwKoaError(ctx, 502, 'Bad Gateway');
         }
     }
@@ -163,7 +169,7 @@ export function createProxyHandler(useBody, options) {
     return async (ctx) => {
         const { pathParams: { appId, path }, } = ctx;
         const app = await options.getApp({ context: ctx, query: { where: { id: appId } } });
-        assertKoaError(!app, ctx, 404, 'App not found');
+        assertKoaCondition(app != null, ctx, 404, 'App not found');
         const appAction = get(app.definition, path);
         const action = supportedActions.find((act) => act === appAction?.type);
         switch (action) {

package/server/utils/resources.js

@@ -3,8 +3,11 @@ import { logger } from '../../logger.js';
 export function generateResourceQuery(ctx, { parseQuery }, resourceDefinition) {
     try {
         return parseQuery({
+            // @ts-expect-error 2322 null is not assignable to type (strictNullChecks)
             $filter: ctx.queryParams.$filter,
+            // @ts-expect-error 2322 null is not assignable to type (strictNullChecks)
             $orderby: ctx.queryParams.$orderby,
+            // @ts-expect-error 2322 null is not assignable to type (strictNullChecks)
             resourceDefinition,
         });
     }
@@ -18,7 +21,7 @@ export function generateResourceQuery(ctx, { parseQuery }, resourceDefinition) {
 }
 export async function deleteResourcesRecursively(type, app, options, context) {
     const { deleteAppResource, getAppResources } = options;
-    const referencingResources = Object.entries(app.definition.resources).filter(([, resourceDefinition]) => Object.values(resourceDefinition.references ?? {}).find((resourceReference) => resourceReference.resource === type));
+    const referencingResources = Object.entries(app.definition.resources ?? {}).filter(([, resourceDefinition]) => Object.values(resourceDefinition.references ?? {}).find((resourceReference) => resourceReference.resource === type));
     for (const [referencingResourceType] of referencingResources) {
         await deleteResourcesRecursively(referencingResourceType, app, options, context);
     }

package/tinyRouter.js

@@ -14,7 +14,7 @@ export function tinyRouter(routes) {
             if (typeof route === 'string') {
                 return path === route;
             }
-            match = path.match(route);
+            match = path.match(route) ?? undefined;
             return match;
         });
         if (!result) {
@@ -27,8 +27,8 @@ export function tinyRouter(routes) {
             }
             m = 'any';
         }
-        ctx.params = match?.groups ? { ...match.groups } : null;
-        return result[m](ctx, next);
+        ctx.params = match?.groups ? { ...match.groups } : undefined;
+        return result[m]?.(ctx, next);
     };
 }
 //# sourceMappingURL=tinyRouter.js.map

package/uploads.d.ts

@@ -0,0 +1,2 @@
+export declare function uploadToBuffer(path: string): Promise<Buffer>;
+export declare function removeUploads(paths: string[]): Promise<void>;

package/uploads.js

@@ -0,0 +1,27 @@
+import { createReadStream } from 'node:fs';
+import { unlink } from 'node:fs/promises';
+import { streamToBuffer } from 'memfs/lib/node/util.js';
+import { logger } from './logger.js';
+// XXX: a bit severe
+// @ts-expect-error 2366 - Function lacks ending return statement and return type does not include 'undefined'
+export async function uploadToBuffer(path) {
+    try {
+        const buffer = await streamToBuffer(await createReadStream(path));
+        await unlink(path);
+        return buffer;
+    }
+    catch (error) {
+        logger.error(error);
+    }
+}
+export async function removeUploads(paths) {
+    for (const path of paths) {
+        try {
+            await unlink(path);
+        }
+        catch (error) {
+            logger.error(error);
+        }
+    }
+}
+//# sourceMappingURL=uploads.js.map

package/versions.d.ts

@@ -0,0 +1,3 @@
+export declare const version: string;
+export declare const faVersion: string;
+export declare const bulmaVersion: string;