@hubspot/ui-extensions-dev-server 1.1.6 → 1.1.8

package/dist/lib/app-functions/constants.js

@@ -0,0 +1,63 @@
+import { AxiosError, HttpStatusCode } from 'axios';
+export const APP_FUNCTIONS_DIRNAME = 'app.functions';
+export const APP_FUNCTIONS_MANIFEST_FILENAME = 'serverless.json';
+export const DEV_SERVER_DEFAULT_PORT = 6789;
+export const EXECUTION_TIMEOUT_MS = 15_000;
+export const PRIVATE_APP_ACCESS_TOKEN = 'PRIVATE_APP_ACCESS_TOKEN';
+export const SECRETS_IN_CONTEXT = [
+    PRIVATE_APP_ACCESS_TOKEN,
+    'HS_ENVIRONMENT',
+    'HS_HUBLET',
+    'HS_SERVERLESS_FUNCTION_ID',
+];
+export const PLATFORM_VERSION = {
+    V20231: '2023.1',
+    V20232: '2023.2',
+    V20251: '2025.1',
+    V20252: '2025.2',
+    UNSTABLE: 'unstable',
+};
+export const defaultServerError = {
+    status: HttpStatusCode.InternalServerError,
+    message: 'Failure observed in UI Extensions Proxy Server. Contact Hubspot Support if the problem persists',
+    category: 'INTERNAL_SERVER_ERROR',
+};
+export const validationError = {
+    category: 'VALIDATION_ERROR',
+    status: HttpStatusCode.BadRequest,
+};
+// Axios errors types: https://github.com/axios/axios/blob/v1.x/README.md#error-types
+export const axiosErrorMappings = {
+    [AxiosError.ERR_FR_TOO_MANY_REDIRECTS]: {
+        ...defaultServerError,
+        message: 'Too many redirects',
+    },
+    [AxiosError.ERR_NETWORK]: {
+        ...defaultServerError,
+        message: 'Network error',
+    },
+    [AxiosError.ERR_BAD_RESPONSE]: {
+        ...validationError,
+        message: 'Invalid JSON Response Body',
+    },
+    [AxiosError.ERR_BAD_REQUEST]: {
+        ...validationError,
+        message: 'Invalid JSON Request Body',
+    },
+    [AxiosError.ERR_INVALID_URL]: {
+        ...validationError,
+        message: 'URL is malformed',
+    },
+    [AxiosError.ETIMEDOUT]: {
+        status: HttpStatusCode.GatewayTimeout,
+        category: 'GATEWAY_TIMEOUT',
+        message: 'Gateway took too long to respond',
+    },
+};
+export const localProxyErrorMappings = {
+    BAD_GATEWAY: {
+        status: 200,
+        category: 'BAD_GATEWAY',
+        message: 'Error returned from Request Uri',
+    },
+};

package/dist/lib/app-functions/context.d.ts

@@ -0,0 +1,3 @@
+import { FunctionContext, LocalExecutionInputs, ObjectQuery, ServiceConfiguration } from './types.ts';
+export declare function fetchObjectContext(config: ServiceConfiguration, objectQuery?: ObjectQuery, accessToken?: string): Promise<FunctionContext>;
+export declare function buildContext(config: ServiceConfiguration, localExecutionInputs: LocalExecutionInputs, secrets: FunctionContext['secrets']): Promise<FunctionContext>;

package/dist/lib/app-functions/context.js

@@ -0,0 +1,65 @@
+import { Client } from '@hubspot/api-client';
+import { isApiException, } from "./types.js";
+import { filterMap } from "./utils.js";
+export async function fetchObjectContext(config, objectQuery, accessToken) {
+    if (!objectQuery) {
+        return {};
+    }
+    const { logger, accountId } = config;
+    const { objectId, objectTypeId, objectPropertyNames } = objectQuery;
+    const propertyNames = objectPropertyNames.filter((field) => field);
+    if (propertyNames.length === 0) {
+        return {};
+    }
+    if (!accessToken) {
+        const errorMessage = `Cannot fetch CRM object properties without a HubSpot API access token. This is not a problem with your code. Please copy the access token for your app at ${config.hubspotWebsiteOrigin}/private-apps/${accountId} and save it in an '.env' file in the 'app.functions' folder. For more details, please see https://developers.hubspot.com/docs/guides/crm/private-apps/serverless-functions.`;
+        throw new Error(errorMessage);
+    }
+    let object;
+    try {
+        object = await getCrmObjectByHubSpotApiClient(accessToken, config.hubspotApiOrigin, objectTypeId, objectId, propertyNames);
+        logger.debug(`Successfully fetched CRM object properties with objectTypeId~${objectTypeId} objectId~${objectId} accountId~${accountId}:`, object?.properties);
+    }
+    catch (err) {
+        if (isApiException(err) && isMaybeWrongAccessToken(err)) {
+            logger.debug(`HubSpot API error:\n${err.message}`);
+            throw new Error(`Failed to fetch CRM object properties with objectTypeId~${objectTypeId} objectId~${objectId} accountId~${accountId}. Please check that the PRIVATE_APP_ACCESS_TOKEN specified in your '.env' file matches that of your app at ${config.hubspotWebsiteOrigin}/private-apps/${accountId}.`);
+        }
+        throw new Error(`Failed to fetch CRM object properties with objectTypeId~${objectTypeId} objectId~${objectId} accountId~${accountId}: ${err}`);
+    }
+    const propertiesToSend = filterMap(object?.properties ?? {}, objectPropertyNames);
+    return {
+        propertiesToSend,
+    };
+}
+function isMaybeWrongAccessToken(err) {
+    /**
+     * Our code controls the `objectTypeId` and `objectId` that are
+     * passed to the execution service from the record page where the
+     * extension is loaded. So when we get a 400 error for
+     * `objectTypeId` being invalid or a 404 error for
+     * `objectId` being not found, it is more likely that the
+     * access token is for the wrong portal. We also include 401 errors
+     * for this check as that's a clear indication of something wrong
+     * with the access token.
+     */
+    return [400, 401, 404].includes(err.code);
+}
+async function getCrmObjectByHubSpotApiClient(accessToken, basePath, objectTypeId, objectId, propertyNames) {
+    const hubspotClient = new Client({
+        accessToken,
+        basePath,
+    });
+    return await hubspotClient.crm.objects.basicApi.getById(objectTypeId, String(objectId), propertyNames);
+}
+export async function buildContext(config, localExecutionInputs, secrets) {
+    const { objectQuery, parameters, event } = localExecutionInputs;
+    const objectContext = await fetchObjectContext(config, objectQuery, secrets?.PRIVATE_APP_ACCESS_TOKEN);
+    return {
+        propertiesToSend: {},
+        parameters,
+        event,
+        secrets,
+        ...objectContext,
+    };
+}

package/dist/lib/app-functions/errorReporter.d.ts

@@ -0,0 +1,22 @@
+type InternalServerErrorContext = {
+    errorType: 'internal_server_error';
+    functionName: string;
+    appId: number;
+    accountId: number;
+};
+type LocalProxyErrorContext = {
+    errorType: 'local_proxy_error';
+    accountId: number;
+    requestUri: string;
+    method: string;
+    correlationId: string;
+};
+type TokenManagerErrorContext = {
+    errorType: 'token_manager_error';
+    operation: 'get_private_app_user_token';
+    appId: number;
+    accountId: number;
+};
+export type ErrorContext = InternalServerErrorContext | LocalProxyErrorContext | TokenManagerErrorContext;
+export declare function reportError(error: unknown, context?: ErrorContext): void;
+export {};

package/dist/lib/app-functions/errorReporter.js

@@ -0,0 +1,42 @@
+import * as Sentry from '@sentry/node';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+const version = JSON.parse(readFileSync(join(import.meta.dirname, '../../../package.json'), 'utf-8')).version;
+const DSN_KEY = 'fbfd0619a2c1af3be058700da25fe9f1';
+const LOGFETCH_DSN = `https://${DSN_KEY}@exceptions.hubspot.com/v2/1`;
+Sentry.init({
+    dsn: LOGFETCH_DSN,
+    release: `@hubspot/app-functions-dev-server@${version}`,
+    initialScope: {
+        tags: {
+            devServerVersion: version,
+        },
+    },
+});
+/**
+ * Here we set up global error handlers to catch any uncaught exceptions or unhandled promise rejections.
+ * They will wait up to 2 seconds to flush the Sentry event queue before exiting the process.
+ */
+process.on('uncaughtException', (error) => {
+    Sentry.captureException(error);
+    Sentry.flush(2000)
+        .then(() => process.exit(1))
+        .catch(() => process.exit(1));
+});
+process.on('unhandledRejection', (reason) => {
+    Sentry.captureException(reason);
+    Sentry.flush(2000)
+        .then(() => process.exit(1))
+        .catch(() => process.exit(1));
+});
+export function reportError(error, context) {
+    Sentry.withScope((scope) => {
+        if (context) {
+            for (const [key, value] of Object.entries(context)) {
+                scope.setTag(key, String(value));
+            }
+            scope.setExtra('errorContext', context);
+        }
+        Sentry.captureException(error);
+    });
+}

package/dist/lib/app-functions/errors.d.ts

@@ -0,0 +1,44 @@
+export declare const Reason: {
+    readonly Timeout: "TIMEOUT";
+    readonly UncaughtError: "UNCAUGHT_ERROR";
+    readonly InvalidResponse: "INVALID_RESPONSE";
+    readonly InvalidFunction: "INVALID_FUNCTION";
+    readonly FunctionNotFound: "FUNCTION_NOT_FOUND";
+};
+type Reason = (typeof Reason)[keyof typeof Reason];
+export declare class ExecutionError extends Error {
+    details: ErrorDetails;
+    reason?: Reason;
+    cause?: unknown;
+    constructor(details: ErrorDetails);
+}
+interface ErrorDetails {
+    reason: Reason;
+    functionName: string;
+    appId?: number;
+    elapsedTimeMs?: number;
+    cause?: unknown;
+}
+export declare function buildBadRequestBody({ details }: ExecutionError): {
+    status: string;
+    message: string;
+    correlationId: string;
+    errors: {
+        subCategory: string;
+        message: string;
+        context: {
+            exception: string[];
+            logId: string[];
+            appFunctionLogId: string[];
+            serverlessFunction: string[];
+        };
+    }[];
+    category: string;
+    subCategory: string;
+};
+export declare function buildInternalErrorBody(): {
+    status: string;
+    message: string;
+    correlationId: string;
+};
+export {};

package/dist/lib/app-functions/errors.js

@@ -0,0 +1,82 @@
+import { formatSeconds } from "./utils.js";
+export const Reason = {
+    Timeout: 'TIMEOUT',
+    UncaughtError: 'UNCAUGHT_ERROR',
+    InvalidResponse: 'INVALID_RESPONSE',
+    InvalidFunction: 'INVALID_FUNCTION',
+    FunctionNotFound: 'FUNCTION_NOT_FOUND',
+};
+export class ExecutionError extends Error {
+    details;
+    reason;
+    cause;
+    constructor(details) {
+        super();
+        this.details = details;
+        this.reason = details.reason;
+        this.cause = details.cause;
+    }
+}
+const ERROR_BUILDERS = {
+    [Reason.Timeout]: buildServerlessFunctionError_timeout,
+    [Reason.UncaughtError]: buildServerlessFunctionError_uncaughtError,
+    [Reason.InvalidResponse]: buildServerlessFunctionError_nonJsonResponse,
+    [Reason.InvalidFunction]: buildServerlessFunctionError_mainNotFound,
+    [Reason.FunctionNotFound]: buildServerlessFunctionError_functionNotFound,
+};
+export function buildBadRequestBody({ details }) {
+    const error = ERROR_BUILDERS[details.reason]?.(details);
+    return {
+        status: 'error',
+        message: "There was a problem reaching the app's API. Contact the app developer for more information.",
+        correlationId: 'n/a',
+        errors: error ? [error] : [],
+        category: 'VALIDATION_ERROR',
+        subCategory: 'GenXExecutionErrorType.APP_ERROR',
+    };
+}
+export function buildInternalErrorBody() {
+    return {
+        status: 'error',
+        message: 'internal error',
+        correlationId: 'n/a',
+    };
+}
+function buildServerlessFunctionError_timeout({ functionName, elapsedTimeMs, }) {
+    const timestamp = new Date().toJSON(); // Ex: '2023-07-21T13:20:39.657Z'
+    const functionId = 'n/a';
+    const elapsedTime = elapsedTimeMs
+        ? formatSeconds(elapsedTimeMs, 2)
+        : 'n/a seconds';
+    const errorMessage = `${timestamp} ${functionId} Task timed out after ${elapsedTime}`;
+    return buildServerlessFunctionError(functionName, errorMessage);
+}
+function buildServerlessFunctionError_uncaughtError({ functionName, cause, }) {
+    const errorMessage = cause ? `${cause}` : '';
+    return buildServerlessFunctionError(functionName, errorMessage);
+}
+function buildServerlessFunctionError_nonJsonResponse({ functionName, }) {
+    const errorMessage = 'Wrong arguments';
+    return buildServerlessFunctionError(functionName, errorMessage);
+}
+function buildServerlessFunctionError_mainNotFound({ functionName, }) {
+    const errorMessage = 'customerPayload.main is not a function';
+    return buildServerlessFunctionError(functionName, errorMessage);
+}
+function buildServerlessFunctionError_functionNotFound({ functionName, appId = 0, }) {
+    // TODO improve server side error
+    const errorMessage = `com.hubspot.apicaller.exceptions.ApiFailure: Api[name=app-functions-executor-client, httpMethod=POST, subPath=/v1/app/${appId}/function/${functionName}] Failed to process your request. Error code was '400'. Error message was:\n{"status":"error","message":"The serverless function ${functionName} doesn't exist in this project. Go to the Activity tab for the project to check its deploy status.","correlationId":"bd3bc53f-db78-4c60-9713-b8a98a6303d4","context":{"SERVERLESS_FUNCTION":["${functionName}"]},"category":"VALIDATION_ERROR","subCategory":"AppFunctionsExecutorErrorType.SERVERLESS_FUNCTION_NOT_FOUND"}`;
+    return buildServerlessFunctionError(functionName, errorMessage);
+}
+function buildServerlessFunctionError(functionName, errorMessage) {
+    return {
+        subCategory: 'ServerlessActionExecutionError.SERVERLESS_FUNCTION_ERROR',
+        message: `The serverless function '${functionName}' failed to execute: ${errorMessage}.`,
+        context: {
+            exception: [errorMessage],
+            logId: ['n/a'],
+            appFunctionLogId: ['n/a'],
+            serverlessFunction: [functionName],
+        },
+    };
+}

package/dist/lib/app-functions/executor.d.ts

@@ -0,0 +1,3 @@
+import { FunctionCallback, LocalExecutionInputs, ServiceConfiguration } from './types.ts';
+import { PrivateAppUserTokenManager } from './services/PrivateAppUserTokenManager.ts';
+export declare function executeFunction(config: ServiceConfiguration, functionName: string, localExecutionInputs: LocalExecutionInputs, callback: FunctionCallback, privateAppUserTokenManager?: PrivateAppUserTokenManager): Promise<void>;

package/dist/lib/app-functions/executor.js

@@ -0,0 +1,131 @@
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import path from 'node:path';
+import { loadFunctionInfo } from "./config.js";
+import { loadSecrets, setProperTokenInSecrets } from "./secrets.js";
+import { buildContext } from "./context.js";
+import { Reason, ExecutionError } from "./errors.js";
+import { diffLists, formatSeconds, throwUnhandledPlatformVersionError, } from "./utils.js";
+import { PLATFORM_VERSION, PRIVATE_APP_ACCESS_TOKEN } from "./constants.js";
+const require = createRequire(import.meta.url);
+export async function executeFunction(config, functionName, localExecutionInputs, callback, privateAppUserTokenManager) {
+    const { logger } = config;
+    const { appId } = localExecutionInputs;
+    const functionInfo = loadFunctionInfo(config, functionName, appId);
+    const functionPath = path.resolve(path.join(functionInfo.srcDir, functionInfo.file));
+    if (!fs.existsSync(functionPath)) {
+        logger.error(`Could not find file ${functionPath}.`);
+        throw new ExecutionError({
+            reason: Reason.FunctionNotFound,
+            functionName,
+            appId,
+        });
+    }
+    delete require.cache[require.resolve(functionPath)];
+    const { main } = require(functionPath);
+    if (!main) {
+        logger.error(`Could not find "main" export in ${functionPath}.`);
+        throw new ExecutionError({
+            reason: Reason.InvalidFunction,
+            functionName,
+        });
+    }
+    const savedEnv = { ...process.env };
+    const initialSecrets = loadSecrets(functionInfo.srcDir);
+    // app token from the env file
+    const privateAppToken = process.env[PRIVATE_APP_ACCESS_TOKEN];
+    // fetch the user token from the local dev service
+    const privateAppUserToken = typeof appId === 'number'
+        ? await privateAppUserTokenManager?.getPrivateAppUserToken(appId, {
+            privateAppToken,
+        })
+        : undefined;
+    const secrets = setProperTokenInSecrets(initialSecrets, logger, privateAppUserToken);
+    const { deleted: missingSecrets } = diffLists(
+    // secrets expected
+    functionInfo.secrets ?? [], 
+    // secrets available
+    Object.keys(process.env));
+    if (missingSecrets.length > 0) {
+        logger.warn(`The following required secrets are missing: ${missingSecrets}. Please supply them as environment variables for local execution in a .env file.`);
+    }
+    let context;
+    try {
+        context = await buildContext(config, localExecutionInputs, secrets);
+    }
+    catch (err) {
+        process.env = savedEnv;
+        throw err;
+    }
+    // eslint-disable-next-line no-async-promise-executor, consistent-return
+    const rawResponse = await new Promise(async (resolve, reject) => {
+        // Start the timer to throw an error after 20s unless the timer
+        // is unref'd after the function completes (even with error)
+        const ms = config.functionTimeoutMs;
+        const timeout = setTimeout(() => {
+            process.env = savedEnv;
+            logger.error(`App function failed to callback within ${formatSeconds(ms, 2)}.`);
+            reject(new ExecutionError({
+                reason: Reason.Timeout,
+                functionName,
+                elapsedTimeMs: ms,
+            }));
+        }, ms);
+        // Catch any error thrown from the function, which may or may not be async
+        try {
+            switch (config.platformVersion) {
+                case PLATFORM_VERSION.V20231:
+                    await main(context, (response) => {
+                        clearTimeout(timeout);
+                        process.env = savedEnv;
+                        resolve(response);
+                    });
+                    break;
+                case PLATFORM_VERSION.V20232:
+                case PLATFORM_VERSION.V20251: {
+                    const response = await main(context);
+                    clearTimeout(timeout);
+                    process.env = savedEnv;
+                    resolve(response);
+                    break;
+                }
+                case PLATFORM_VERSION.V20252:
+                case PLATFORM_VERSION.UNSTABLE: {
+                    logger.error(`Serverless functions are not yet supported in platform version ${config.platformVersion}.`);
+                    break;
+                }
+                default:
+                    return throwUnhandledPlatformVersionError(config.platformVersion);
+            }
+        }
+        catch (error) {
+            clearTimeout(timeout);
+            process.env = savedEnv;
+            logger.error(`App function encountered an uncaught error.`, error);
+            reject(new ExecutionError({
+                reason: Reason.UncaughtError,
+                functionName,
+                cause: error,
+            }));
+        }
+        finally {
+            timeout.unref();
+        }
+    });
+    // Confirm that the response is valid JSON
+    let jsonResponse = null;
+    try {
+        jsonResponse =
+            rawResponse === undefined
+                ? null
+                : JSON.parse(JSON.stringify(rawResponse));
+    }
+    catch (error) {
+        logger.error(`App function reponse is not valid JSON.`);
+        throw new ExecutionError({
+            reason: Reason.InvalidResponse,
+            functionName,
+        });
+    }
+    callback(jsonResponse);
+}

package/dist/lib/app-functions/index.d.ts

@@ -0,0 +1,4 @@
+export { executeFunction } from './executor.ts';
+export * from './services/index.ts';
+export { reportError } from './errorReporter.ts';
+export * from './types.ts';

package/dist/lib/app-functions/index.js

@@ -0,0 +1,4 @@
+export { executeFunction } from "./executor.js";
+export * from "./services/index.js";
+export { reportError } from "./errorReporter.js";
+export * from "./types.js";

package/dist/lib/app-functions/secrets.d.ts

@@ -0,0 +1,5 @@
+import type { FunctionContext, ProxyServiceConfig, PrivateAppUserToken } from './types.ts';
+type Secrets = FunctionContext['secrets'];
+export declare function setProperTokenInSecrets(secrets: Secrets, logger: ProxyServiceConfig['logger'], privateAppUserToken?: PrivateAppUserToken): Secrets;
+export declare function loadSecrets(srcDir: string): Secrets;
+export {};

package/dist/lib/app-functions/secrets.js

@@ -0,0 +1,56 @@
+// TODO: Replace dotenv.parse with `import { parseEnv } from 'node:util'` once the CLI is on Node 22+
+import dotenv from 'dotenv';
+import fs from 'node:fs';
+import path from 'node:path';
+import { PRIVATE_APP_ACCESS_TOKEN, SECRETS_IN_CONTEXT } from "./constants.js";
+import { PrivateAppUserTokenManager } from "./services/PrivateAppUserTokenManager.js";
+function getEnvPath(srcDir) {
+    const mode = process.env.NODE_ENV;
+    return (mode
+        ? [`.env.${mode}.local`, '.env.local', `.env.${mode}`, '.env']
+        : ['.env.local', '.env'])
+        .map((fileName) => path.join(srcDir, fileName))
+        .find(fs.existsSync);
+}
+export function setProperTokenInSecrets(secrets, logger, privateAppUserToken) {
+    if (!privateAppUserToken)
+        return secrets;
+    const privateAppToken = secrets?.[PRIVATE_APP_ACCESS_TOKEN];
+    if (privateAppToken && privateAppUserToken) {
+        /*
+         * Make sure that the privateAppUserToken has all the scopes from the privateAppToken.
+         * If they do, suggest that they remove the privateAppToken from the environment file.
+         */
+        if (PrivateAppUserTokenManager.doesUserTokenContainAppTokenScopes(privateAppUserToken)) {
+            logger.info('The private app user token was overridden by the PRIVATE_APP_ACCESS_TOKEN in the environment file. For local development, you no longer need a PRIVATE_APP_ACCESS_TOKEN in the environment file. You can safely remove it.');
+        }
+        // privateAppToken it's already in the secrets and it takes precedence. just return
+        return secrets;
+    }
+    // has only one of the tokens. Set the proper one in the secrets taking into account that privateAppToken takes precedence
+    const result = { ...secrets };
+    const theToken = privateAppToken ?? privateAppUserToken?.userTokenKey;
+    result[PRIVATE_APP_ACCESS_TOKEN] = theToken;
+    process.env[PRIVATE_APP_ACCESS_TOKEN] = theToken;
+    return result;
+}
+export function loadSecrets(srcDir) {
+    const envPath = getEnvPath(srcDir);
+    if (envPath) {
+        try {
+            const content = fs.readFileSync(envPath, 'utf8');
+            Object.assign(process.env, dotenv.parse(content));
+        }
+        catch (error) {
+            // Silently ignore read errors to match dotenv's quiet behavior
+        }
+    }
+    const secrets = {};
+    SECRETS_IN_CONTEXT.forEach((secretName) => {
+        const secretValue = process.env[secretName];
+        if (typeof secretValue === 'string') {
+            secrets[secretName] = secretValue;
+        }
+    });
+    return secrets;
+}

package/dist/lib/app-functions/services/AppFunctionExecutionService.d.ts

@@ -0,0 +1,2 @@
+import { ServiceConfiguration } from '../types.ts';
+export declare const AppFunctionExecutionService: (partialConfig: Partial<ServiceConfiguration>) => import("express-serve-static-core").Express;

package/dist/lib/app-functions/services/AppFunctionExecutionService.js

@@ -0,0 +1,55 @@
+import express from 'express';
+import cors from 'cors';
+import { executeFunction } from "../executor.js";
+import { buildServiceConfiguration } from "../config.js";
+import { buildBadRequestBody, buildInternalErrorBody, ExecutionError, } from "../errors.js";
+import { PrivateAppUserTokenManager } from "./PrivateAppUserTokenManager.js";
+import { reportError } from "../errorReporter.js";
+export const AppFunctionExecutionService = (partialConfig) => {
+    const config = setupConfig(partialConfig);
+    const { logger, accountId } = config;
+    const privateAppUserTokenManager = new PrivateAppUserTokenManager(accountId, logger);
+    privateAppUserTokenManager.init();
+    const app = express();
+    app.use(cors());
+    app.use(express.json());
+    app.post('/action/function/:appId', async (req, res) => {
+        const appId = Number(req.params.appId);
+        const request = req.body;
+        const { serverlessFunction: functionName, objectQuery, parameters, event, } = request;
+        const onSuccess = (response = null) => {
+            logger.debug(`${new Date().toISOString()} - App function "${functionName}" execution succeeded`);
+            res.status(200).json({ logId: 'n/a', response });
+        };
+        try {
+            await executeFunction(config, functionName, { appId, objectQuery, parameters, event }, onSuccess, privateAppUserTokenManager);
+        }
+        catch (err) {
+            if (err instanceof ExecutionError) {
+                const response = buildBadRequestBody(err);
+                logger.warn(`${new Date().toISOString()} - App function "${functionName}" execution failed`);
+                res.status(400).json(response);
+            }
+            else {
+                reportError(err, {
+                    functionName,
+                    appId,
+                    accountId,
+                    errorType: 'internal_server_error',
+                });
+                const response = buildInternalErrorBody();
+                logger.error(err);
+                logger.warn(`${new Date().toISOString()} - App function "${functionName}" execution failed due to server internal error`);
+                res.status(500).json(response);
+            }
+        }
+    });
+    return app;
+};
+function setupConfig(partialConfig) {
+    if (!partialConfig.app?.path) {
+        throw new Error('Cannot instantiate app function execution service: Path to the application directory is missing');
+    }
+    const { app: { path: appPath }, ...rest } = partialConfig;
+    return buildServiceConfiguration(appPath, rest);
+}

package/dist/lib/app-functions/services/AppProxyService.d.ts

@@ -0,0 +1,5 @@
+import { AxiosError } from 'axios';
+import { LocalDevUrlMapping, ProxyServiceConfig, ProxyServerError } from '../types.ts';
+export declare const mapToLocalUrl: (localDevUrlMapping: LocalDevUrlMapping, requestUri: string, allowedUrls: string[], logger: ProxyServiceConfig["logger"]) => string;
+export declare const extractErrorData: (e: unknown | AxiosError) => ProxyServerError;
+export declare const AppProxyService: ({ localDevUrlMapping, logger, accountId, allowedUrls, }: ProxyServiceConfig) => import("express-serve-static-core").Express;