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

package/dist/lib/__tests__/app-functions/services/PrivateAppUserTokenManager.spec.js

@@ -0,0 +1,243 @@
+import { vi, describe, beforeEach, afterEach, it, expect, } from 'vitest';
+import { scopesOnAccessToken as __scopesOnAccessToken } from '@hubspot/local-dev-lib/personalAccessKey';
+import { PrivateAppUserTokenManager } from "../../../app-functions/services/PrivateAppUserTokenManager.js";
+import { fetchPrivateAppUserToken as __fetchPrivateAppUserToken, createPrivateAppUserToken as __createPrivateAppUserToken, updatePrivateAppUserToken as __updatePrivateAppUserToken, } from "../../../app-functions/api/privateAppUserToken.js";
+import { HubSpotHttpError } from '@hubspot/local-dev-lib/models/HubSpotHttpError';
+import { AxiosError, AxiosHeaders } from 'axios';
+import { generateTokensEnableMessage, generateMissingScopesMessage, generateMissingScopesMoreContextMessage, } from "../../../app-functions/services/messages.js";
+vi.mock('@hubspot/local-dev-lib/personalAccessKey');
+vi.mock('../../../app-functions/api/privateAppUserToken.ts');
+const scopesOnAccessToken = __scopesOnAccessToken;
+const fetchPrivateAppUserToken = __fetchPrivateAppUserToken;
+const createPrivateAppUserToken = __createPrivateAppUserToken;
+const updatePrivateAppUserToken = __updatePrivateAppUserToken;
+function mockAxiosResponse(data, status = 200, statusText = 'OK', headers = new AxiosHeaders(), config = {}) {
+    // Type cast needed due to AxiosHeaders type conflict between local axios@1.12.0 and @hubspot/local-dev-lib's axios dependency
+    // The runtime behavior is correct, just incompatible AxiosHeaders types between different axios versions
+    return {
+        data,
+        status,
+        statusText,
+        headers,
+        config: { ...config, headers },
+    };
+}
+describe('lib/PrivateAppUserTokenManager', () => {
+    const accountId = 123;
+    const pakScopesTokenEnabled = [
+        'developer.private_app.temporary_token.read',
+        'developer.private_app.temporary_token.write',
+    ];
+    const pakScopesTokenDisabled = ['developer.projects.read'];
+    let manager;
+    let logger;
+    beforeEach(() => {
+        logger = {
+            error: vi.fn(),
+            debug: vi.fn(),
+            info: vi.fn(),
+            warn: vi.fn(),
+        };
+    });
+    describe('init()', () => {
+        beforeEach(() => {
+            manager = new PrivateAppUserTokenManager(accountId, logger);
+        });
+        afterEach(() => {
+            manager.cleanup();
+        });
+        it('should enable PrivateAppUserTokenManager when personal access key has all scopes', async () => {
+            scopesOnAccessToken.mockResolvedValue(pakScopesTokenEnabled);
+            await manager.init();
+            expect(manager.isEnabled()).toBe(true);
+            // logs the proper messages info. there's no warn/devbug
+            expect(logger.info).toHaveBeenCalledWith(generateTokensEnableMessage(accountId));
+            expect(logger.debug).not.toHaveBeenCalled();
+            expect(logger.warn).not.toHaveBeenCalled();
+        });
+        it('should not enable PrivateAppUserTokenManager if the personal access key does not contain scopes', async () => {
+            scopesOnAccessToken.mockResolvedValue(pakScopesTokenDisabled);
+            await manager.init();
+            expect(manager.isEnabled()).toBe(false);
+            // logs the proper info and debug messages. there is no warn
+            expect(logger.info).toHaveBeenCalledWith(generateMissingScopesMessage(accountId));
+            expect(logger.debug).toHaveBeenCalledWith(generateMissingScopesMoreContextMessage(accountId));
+            expect(logger.warn).not.toHaveBeenCalled();
+        });
+    });
+    describe('getPrivateAppUserToken()', () => {
+        const systemTime = new Date(Date.UTC(2024, 5, 1, 0, 0, 0));
+        const token = {
+            userId: 111,
+            portalId: 123,
+            appId: 345,
+            scopeGroups: ['crm.objects.contacts.read'],
+            userTokenKey: 'pat-na1-u-FFFFFFFF-FFFF-FFFF-FFFF-FFFFFFFFFFFF',
+            clientId: 'my-client-id',
+            expiresAt: '2024-06-01T01:00:00Z',
+        };
+        const tokenWithMoreScopes = {
+            ...token,
+            scopeGroups: ['crm.objects.contacts.read', 'crm.objects.contacts.write'],
+        };
+        const refreshedToken = { ...token, expiresAt: '2024-06-01T02:00:00Z' };
+        const expiredToken = { ...token, expiresAt: '2024-05-30T00:00:00Z' };
+        const headers = new AxiosHeaders();
+        const config = { url: 'https://api.google.com', headers };
+        const notFoundError = new HubSpotHttpError('Not Found', {
+            cause: new AxiosError('msg', 'code', config, undefined, {
+                status: 404,
+                data: { message: 'Not Found' },
+                statusText: 'Not Found',
+                config,
+                headers,
+            }),
+        });
+        beforeEach(() => {
+            vi.resetAllMocks();
+            scopesOnAccessToken.mockResolvedValue(pakScopesTokenEnabled);
+            vi.spyOn(global, 'setInterval');
+            vi.useFakeTimers();
+            vi.setSystemTime(systemTime);
+            manager = new PrivateAppUserTokenManager(accountId, logger);
+            manager.init();
+        });
+        afterEach(() => {
+            manager.cleanup();
+            vi.clearAllTimers();
+        });
+        it('should return undefined if class is not initilized', async () => {
+            manager = new PrivateAppUserTokenManager(accountId, logger); // set to new instance not initialized
+            const result = await manager.getPrivateAppUserToken(accountId);
+            expect(result).toBeUndefined();
+        });
+        it('should return undefined if user does not have the scopes', async () => {
+            scopesOnAccessToken.mockResolvedValue(pakScopesTokenDisabled);
+            manager = new PrivateAppUserTokenManager(accountId, logger); // set to new instance not initialized
+            await manager.init();
+            const result = await manager.getPrivateAppUserToken(accountId);
+            expect(result).toBeUndefined();
+        });
+        it('should fetch a existing valid Private App User Token', async () => {
+            fetchPrivateAppUserToken.mockResolvedValue(mockAxiosResponse(token));
+            const result = await manager.getPrivateAppUserToken(token.appId);
+            expect(result?.userTokenKey).toEqual(token.userTokenKey);
+        });
+        it('should used cached Private App User Token', async () => {
+            fetchPrivateAppUserToken.mockResolvedValue(mockAxiosResponse(token));
+            await manager.getPrivateAppUserToken(token.appId);
+            const result = await manager.getPrivateAppUserToken(token.appId);
+            expect(result?.userTokenKey).toEqual(token.userTokenKey);
+            expect(fetchPrivateAppUserToken).toHaveBeenCalledTimes(1);
+        });
+        it('should refresh existing expired Private App User Token', async () => {
+            fetchPrivateAppUserToken.mockResolvedValue(mockAxiosResponse(expiredToken));
+            updatePrivateAppUserToken.mockResolvedValue(mockAxiosResponse(token));
+            const result = await manager.getPrivateAppUserToken(token.appId);
+            expect(result?.userTokenKey).toEqual(token.userTokenKey);
+            expect(updatePrivateAppUserToken).toHaveBeenCalledTimes(1);
+            expect(updatePrivateAppUserToken).toHaveBeenCalledWith(expect.objectContaining({
+                expiresAt: '2024-06-01T00:15:00.000Z',
+            }));
+        });
+        it('should create a new Private App User Token if none exist', async () => {
+            fetchPrivateAppUserToken.mockRejectedValue(notFoundError);
+            createPrivateAppUserToken.mockResolvedValue(mockAxiosResponse(token, 200));
+            const result = await manager.getPrivateAppUserToken(token.appId);
+            expect(result?.userTokenKey).toEqual(token.userTokenKey);
+            expect(createPrivateAppUserToken).toHaveBeenCalledTimes(1);
+            expect(createPrivateAppUserToken).toHaveBeenCalledWith(expect.objectContaining({
+                expiresAt: '2024-06-01T00:15:00.000Z',
+            }));
+        });
+        it('should refresh cached token if it is within the threashold and user request a new token', async () => {
+            // token expires in 1 hour. try 56 minutes to test threadhold
+            const fiftyMinutesMilli = 56 * 60 * 1000;
+            fetchPrivateAppUserToken.mockResolvedValue(mockAxiosResponse(token));
+            updatePrivateAppUserToken.mockResolvedValue(mockAxiosResponse(refreshedToken));
+            const tokenResp = await manager.getPrivateAppUserToken(token.appId);
+            expect(tokenResp?.userTokenKey).toEqual(token.userTokenKey);
+            vi.advanceTimersByTime(fiftyMinutesMilli);
+            await manager.getPrivateAppUserToken(token.appId);
+            expect(updatePrivateAppUserToken).toHaveBeenCalledTimes(1);
+        });
+        it('should not refresh token is still valid', async () => {
+            // token expires in 1 hour. try 10 minutes to test threadhold
+            const tenMinutesMilli = 10 * 60 * 1000;
+            fetchPrivateAppUserToken.mockResolvedValue(mockAxiosResponse(token));
+            updatePrivateAppUserToken.mockResolvedValue(mockAxiosResponse(refreshedToken));
+            const tokenResp = await manager.getPrivateAppUserToken(token.appId);
+            expect(tokenResp?.userTokenKey).toEqual(token.userTokenKey);
+            vi.advanceTimersByTime(tenMinutesMilli);
+            await manager.getPrivateAppUserToken(token.appId);
+            expect(updatePrivateAppUserToken).not.toHaveBeenCalled();
+        });
+        it('should update token is missing scopes', async () => {
+            fetchPrivateAppUserToken.mockResolvedValue(mockAxiosResponse(token));
+            updatePrivateAppUserToken.mockResolvedValue(mockAxiosResponse(tokenWithMoreScopes));
+            await manager.getPrivateAppUserToken(token.appId);
+            const tokenResp = await manager.getPrivateAppUserToken(token.appId, {
+                scopeGroups: tokenWithMoreScopes.scopeGroups,
+            });
+            expect(tokenResp?.userTokenKey).toEqual(token.userTokenKey);
+            expect(fetchPrivateAppUserToken).toHaveBeenCalledTimes(2); // initial get, and then fetches again when scopes don't match in cached token
+            expect(updatePrivateAppUserToken).toHaveBeenCalledTimes(1);
+        });
+        it('should clear token refresh if cleanup is called', async () => {
+            fetchPrivateAppUserToken.mockResolvedValue(mockAxiosResponse(token));
+            await manager.getPrivateAppUserToken(token.appId);
+            manager.cleanup();
+            vi.advanceTimersByTime(60 * 60 * 1000);
+            expect(updatePrivateAppUserToken).not.toHaveBeenCalled();
+        });
+    });
+    describe('doesUserTokenContainAppTokenScopes', () => {
+        const tokenWithMatchingScopes = {
+            userId: 111,
+            portalId: 123,
+            appId: 345,
+            scopeGroups: ['crm.objects.contacts.read', 'crm.objects.contacts.write'],
+            userTokenKey: 'pat-na1-u-FFFFFFFF-FFFF-FFFF-FFFF-FFFFFFFFFFFF',
+            clientId: 'my-client-id',
+            expiresAt: '2024-06-01T01:00:00Z',
+            privateAppTokenInfo: {
+                userId: 111,
+                portalId: 123,
+                appId: 345,
+                scopeGroups: [
+                    'crm.objects.contacts.read',
+                    'crm.objects.contacts.write',
+                ],
+                expiresAt: '2024-06-01T01:00:00Z',
+            },
+        };
+        it('should return true if the scopes match', () => {
+            expect(PrivateAppUserTokenManager.doesUserTokenContainAppTokenScopes(tokenWithMatchingScopes)).toBeTruthy();
+        });
+        it('should return false there is no PrivateAppToken', () => {
+            const localToken = {
+                ...tokenWithMatchingScopes,
+                privateAppTokenInfo: undefined,
+            };
+            expect(PrivateAppUserTokenManager.doesUserTokenContainAppTokenScopes(localToken)).toBeFalsy();
+        });
+        it('should return false if PrivateAppUserToken has extra scopes that are not in PrivateAppToken', () => {
+            const localToken = {
+                ...tokenWithMatchingScopes,
+                scopeGroups: [
+                    'crm.objects.contacts.read',
+                    'crm.objects.contacts.write',
+                    'crm.objects.deals.write',
+                ],
+            };
+            expect(PrivateAppUserTokenManager.doesUserTokenContainAppTokenScopes(localToken)).toBeTruthy();
+        });
+        it('should return true if PrivateAppUserToken is missing scopes', () => {
+            const localToken = {
+                ...tokenWithMatchingScopes,
+                scopeGroups: ['crm.objects.contacts.write'],
+            };
+            expect(PrivateAppUserTokenManager.doesUserTokenContainAppTokenScopes(localToken)).toBeFalsy();
+        });
+    });
+});

package/dist/lib/__tests__/app-functions/services/services_v20231.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/__tests__/app-functions/services/services_v20231.spec.js

@@ -0,0 +1,319 @@
+import { describe, it, expect, vi, afterEach, beforeEach, } from 'vitest';
+import httpMocks from 'node-mocks-http';
+import { EventEmitter } from 'node:events';
+import { AppFunctionExecutionService } from "../../../app-functions/services/index.js";
+import { TEST_CONFIG_V20231 as TEST_CONFIG } from "../fixtures/constants.js";
+import * as executor from "../../../app-functions/executor.js";
+import { scopesOnAccessToken as __scopesOnAccessToken } from '@hubspot/local-dev-lib/personalAccessKey';
+import { USER_TOKEN_READ, USER_TOKEN_WRITE, } from "../../../app-functions/services/constants.js";
+import { PrivateAppUserTokenManager } from "../../../app-functions/services/PrivateAppUserTokenManager.js";
+vi.mock('../../../app-functions/services/PrivateAppUserTokenManager.ts');
+vi.mock('@hubspot/local-dev-lib/personalAccessKey');
+const scopesOnAccessToken = __scopesOnAccessToken;
+const callAppFunction = async (functionName, parameters) => {
+    const request = httpMocks.createRequest({
+        method: 'POST',
+        url: '/action/function/100',
+        params: {
+            id: 100,
+        },
+        body: {
+            serverlessFunction: functionName,
+            parameters,
+        },
+    });
+    const response = httpMocks.createResponse({
+        req: request,
+        eventEmitter: EventEmitter,
+    });
+    const handler = AppFunctionExecutionService(TEST_CONFIG);
+    // Hold response until the handler finishes writing to it. THis must
+    // be set up before calling the handler or it may miss the `end` event.
+    const responsePromised = new Promise((resolve) => {
+        response.on('end', () => {
+            resolve(response);
+        });
+    });
+    await handler(request, response);
+    return await responsePromised;
+};
+/**
+ * Validate the service for executing app functions
+ */
+describe('app function dev server', () => {
+    const initialEnvJson = JSON.stringify(process.env);
+    beforeEach(() => {
+        scopesOnAccessToken.mockResolvedValue([USER_TOKEN_READ, USER_TOKEN_WRITE]);
+    });
+    afterEach(() => {
+        // restore process.env
+        process.env = JSON.parse(initialEnvJson);
+        vi.resetAllMocks();
+        vi.restoreAllMocks();
+    });
+    it('returns "200 OK" response if function execution succeeded', async () => {
+        const getTokenspy = vi.spyOn(PrivateAppUserTokenManager.prototype, 'getPrivateAppUserToken');
+        const response = await callAppFunction('returns-text');
+        // Validate response status and body
+        expect(response.statusCode).toEqual(200);
+        expect(response._getJSONData()).toEqual({
+            logId: 'n/a',
+            response: 'result',
+        });
+        // Validate log output
+        expect(TEST_CONFIG.logger.debug).toHaveBeenCalledWith(expect.stringContaining('App function "returns-text" execution succeeded'));
+        expect(TEST_CONFIG.logger.warn).toHaveBeenCalledTimes(0);
+        expect(TEST_CONFIG.logger.error).toHaveBeenCalledTimes(0);
+        // Validate process.env is put back to what it was before the call
+        expect(process.env).toEqual(JSON.parse(initialEnvJson));
+        // get the token
+        expect(getTokenspy).toHaveBeenCalledTimes(1);
+    });
+    it('returns "400 Bad Request" response if function execution failed', async () => {
+        const response = await callAppFunction('throws-error');
+        // Validate response status and body
+        expect(response.statusCode).toEqual(400);
+        const body = response._getJSONData();
+        expect(body).toHaveProperty('status', 'error');
+        expect(body).toHaveProperty('category', 'VALIDATION_ERROR');
+        const exception = body.errors?.[0]?.context?.exception?.[0];
+        expect(exception).toEqual('Error: Oops');
+        // Validate log output
+        expect(TEST_CONFIG.logger.warn).toHaveBeenCalledWith(expect.stringContaining('App function "throws-error" execution failed'));
+        expect(TEST_CONFIG.logger.error).toHaveBeenCalledWith('App function encountered an uncaught error.', expect.anything());
+        // Validate process.env is put back to what it was before the call
+        expect(process.env).toEqual(JSON.parse(initialEnvJson));
+    });
+    describe('handles asynchronous functions (promise chaining)', () => {
+        it('returns "200 OK" response if function returns a promise that resolves', async () => {
+            const response = await callAppFunction('returns-promise-resolved');
+            // Validate response status and body
+            expect(response.statusCode).toEqual(200);
+            expect(response._getJSONData()).toEqual({
+                logId: 'n/a',
+                response: { result: 'simulated' },
+            });
+            // Validate log output
+            expect(TEST_CONFIG.logger.debug).toHaveBeenCalledWith(expect.stringContaining('App function "returns-promise-resolved" execution succeeded'));
+            expect(TEST_CONFIG.logger.warn).toHaveBeenCalledTimes(0);
+            expect(TEST_CONFIG.logger.error).toHaveBeenCalledTimes(0);
+            // Validate process.env is put back to what it was before the call
+            expect(process.env).toEqual(JSON.parse(initialEnvJson));
+        });
+        it('returns "400 Bad Request" response if function returns a promise that rejects', async () => {
+            const response = await callAppFunction('returns-promise-rejected');
+            // Validate response status and body
+            expect(response.statusCode).toEqual(400);
+            const body = response._getJSONData();
+            expect(body).toHaveProperty('status', 'error');
+            expect(body).toHaveProperty('category', 'VALIDATION_ERROR');
+            const exception = body.errors?.[0]?.context?.exception?.[0];
+            expect(exception).toEqual('Error: fail');
+            // Validate log output
+            expect(TEST_CONFIG.logger.warn).toHaveBeenCalledWith(expect.stringContaining('App function "returns-promise-rejected" execution failed'));
+            expect(TEST_CONFIG.logger.error).toHaveBeenCalledWith('App function encountered an uncaught error.', expect.anything());
+            // Validate process.env is put back to what it was before the call
+            expect(process.env).toEqual(JSON.parse(initialEnvJson));
+        });
+    });
+    describe('handles asynchronous functions (async/await)', () => {
+        it('returns "200 OK" response if an async function execution succeeded', async () => {
+            const response = await callAppFunction('async-succeeds');
+            // Validate response status and body
+            expect(response.statusCode).toEqual(200);
+            expect(response._getJSONData()).toEqual({
+                logId: 'n/a',
+                response: { result: 'simulated' },
+            });
+            // Validate log output
+            expect(TEST_CONFIG.logger.debug).toHaveBeenCalledWith(expect.stringContaining('App function "async-succeeds" execution succeeded'));
+            expect(TEST_CONFIG.logger.warn).toHaveBeenCalledTimes(0);
+            expect(TEST_CONFIG.logger.error).toHaveBeenCalledTimes(0);
+            // Validate process.env is put back to what it was before the call
+            expect(process.env).toEqual(JSON.parse(initialEnvJson));
+        });
+        it('returns "400 Bad Request" response if an async function execution failed', async () => {
+            const response = await callAppFunction('async-fails');
+            // Validate response status and body
+            expect(response.statusCode).toEqual(400);
+            const body = response._getJSONData();
+            expect(body).toHaveProperty('status', 'error');
+            expect(body).toHaveProperty('category', 'VALIDATION_ERROR');
+            const exception = body.errors?.[0]?.context?.exception?.[0];
+            expect(exception).toEqual('Error: fail');
+            // Validate log output
+            expect(TEST_CONFIG.logger.warn).toHaveBeenCalledWith(expect.stringContaining('App function "async-fails" execution failed'));
+            expect(TEST_CONFIG.logger.error).toHaveBeenCalledWith('App function encountered an uncaught error.', expect.anything());
+            // Validate process.env is put back to what it was before the call
+            expect(process.env).toEqual(JSON.parse(initialEnvJson));
+        });
+    });
+    describe('handles functions with floating promises (only 2023.1)', () => {
+        it('returns "200 OK" response if function makes a promise that resolves and calls callback', async () => {
+            const response = await callAppFunction('callback-on-promise-resolved');
+            // Validate response status and body
+            expect(response.statusCode).toEqual(200);
+            expect(response._getJSONData()).toEqual({
+                logId: 'n/a',
+                response: { result: 'simulated' },
+            });
+            // Validate log output
+            expect(TEST_CONFIG.logger.debug).toHaveBeenCalledWith(expect.stringContaining('App function "callback-on-promise-resolved" execution succeeded'));
+            expect(TEST_CONFIG.logger.warn).toHaveBeenCalledTimes(0);
+            expect(TEST_CONFIG.logger.error).toHaveBeenCalledTimes(0);
+            // Validate process.env is put back to what it was before the call
+            expect(process.env).toEqual(JSON.parse(initialEnvJson));
+        });
+        it('returns "200 OK" response if function makes a promise that rejects and calls callback', async () => {
+            const response = await callAppFunction('callback-on-promise-rejected');
+            // Validate response status and body
+            expect(response.statusCode).toEqual(200);
+            expect(response._getJSONData()).toEqual({
+                logId: 'n/a',
+                response: { error: 'Error: fail' },
+            });
+            // Validate log output
+            expect(TEST_CONFIG.logger.debug).toHaveBeenCalledWith(expect.stringContaining('App function "callback-on-promise-rejected" execution succeeded'));
+            expect(TEST_CONFIG.logger.warn).toHaveBeenCalledTimes(0);
+            expect(TEST_CONFIG.logger.error).toHaveBeenCalledTimes(0);
+            // Validate process.env is put back to what it was before the call
+            expect(process.env).toEqual(JSON.parse(initialEnvJson));
+        });
+    });
+    it('returns "400 Bad Request" response if function not found', async () => {
+        const response = await callAppFunction('does-not-exist');
+        // Validate response status and body
+        expect(response.statusCode).toEqual(400);
+        const body = response._getJSONData();
+        expect(body).toHaveProperty('status', 'error');
+        expect(body).toHaveProperty('category', 'VALIDATION_ERROR');
+        const exception = body.errors?.[0]?.context?.exception?.[0];
+        expect(exception).toMatch(/doesn't exist in this project/);
+        // Validate log output
+        expect(TEST_CONFIG.logger.warn).toHaveBeenCalledWith(expect.stringContaining('App function "does-not-exist" execution failed'));
+        expect(TEST_CONFIG.logger.error).toHaveBeenCalledWith(expect.stringContaining('Could not find file'));
+        // Validate process.env is put back to what it was before the call
+        expect(process.env).toEqual(JSON.parse(initialEnvJson));
+    });
+    it('returns "400 Bad Request" response if function does not export main', async () => {
+        // TEST_CONFIG.functionTimeoutMs = 250
+        const response = await callAppFunction('does-not-export-main');
+        // Validate response status and body
+        expect(response.statusCode).toEqual(400);
+        const body = response._getJSONData();
+        expect(body).toHaveProperty('status', 'error');
+        expect(body).toHaveProperty('category', 'VALIDATION_ERROR');
+        const exception = body.errors?.[0]?.context?.exception?.[0];
+        expect(exception).toMatch(/customerPayload\.main is not a function/);
+        // Validate log output
+        expect(TEST_CONFIG.logger.warn).toHaveBeenCalledWith(expect.stringContaining('App function "does-not-export-main" execution failed'));
+        expect(TEST_CONFIG.logger.error).toHaveBeenCalledWith(expect.stringContaining('Could not find "main" export in'));
+        // Validate process.env is put back to what it was before the call
+        expect(process.env).toEqual(JSON.parse(initialEnvJson));
+    });
+    it('returns "400 Bad Request" response if function returns invalid json', async () => {
+        // TEST_CONFIG.functionTimeoutMs = 250
+        const response = await callAppFunction('returns-function');
+        // Validate response status and body
+        expect(response.statusCode).toEqual(400);
+        const body = response._getJSONData();
+        expect(body).toHaveProperty('status', 'error');
+        expect(body).toHaveProperty('category', 'VALIDATION_ERROR');
+        const exception = body.errors?.[0]?.context?.exception?.[0];
+        expect(exception).toMatch(/Wrong arguments/);
+        // Validate log output
+        expect(TEST_CONFIG.logger.warn).toHaveBeenCalledWith(expect.stringContaining('App function "returns-function" execution failed'));
+        expect(TEST_CONFIG.logger.error).toHaveBeenCalledWith('App function reponse is not valid JSON.');
+        // Validate process.env is put back to what it was before the call
+        expect(process.env).toEqual(JSON.parse(initialEnvJson));
+    });
+    it('returns "200 OK" response if function returns before timeout', async () => {
+        // TEST_CONFIG.functionTimeoutMs = 250
+        const response = await callAppFunction('times-out', { delayMs: 200 });
+        const variance = 5; // milliseconds
+        // Validate response status and body
+        expect(response.statusCode).toEqual(200);
+        const body = response._getJSONData();
+        expect(body).toEqual({
+            logId: 'n/a',
+            response: { status: 'success', elapsedMs: expect.anything() },
+        });
+        expect(body.response.elapsedMs).toBeGreaterThanOrEqual(200 - variance);
+        expect(body.response.elapsedMs).toBeLessThanOrEqual(200 + variance);
+        // Validate log output
+        expect(TEST_CONFIG.logger.debug).toHaveBeenCalledWith(expect.stringContaining('App function "times-out" execution succeeded'));
+        expect(TEST_CONFIG.logger.warn).toHaveBeenCalledTimes(0);
+        expect(TEST_CONFIG.logger.error).toHaveBeenCalledTimes(0);
+        // Validate process.env is put back to what it was before the call
+        expect(process.env).toEqual(JSON.parse(initialEnvJson));
+    });
+    it('returns "400 Bad Request" response if function returns after timeout', async () => {
+        // TEST_CONFIG.functionTimeoutMs = 250
+        const response = await callAppFunction('times-out', { delayMs: 300 });
+        // Validate response status and body
+        expect(response.statusCode).toEqual(400);
+        const body = response._getJSONData();
+        expect(body).toHaveProperty('status', 'error');
+        expect(body).toHaveProperty('category', 'VALIDATION_ERROR');
+        const exception = body.errors?.[0]?.context?.exception?.[0];
+        expect(exception).toMatch(/Task timed out after/);
+        // Validate log output
+        expect(TEST_CONFIG.logger.warn).toHaveBeenCalledWith(expect.stringContaining('App function "times-out" execution failed'));
+        expect(TEST_CONFIG.logger.error).toHaveBeenCalledWith('App function failed to callback within 0.25 second.');
+        // Validate process.env is put back to what it was before the call
+        expect(process.env).toEqual(JSON.parse(initialEnvJson));
+    });
+    it('returns "500 Internal Server Error" response if something went wrong', async () => {
+        const error = new Error('Something went terribly wrong!');
+        vi.spyOn(executor, 'executeFunction').mockImplementation(() => {
+            throw error;
+        });
+        // Act
+        const response = await callAppFunction('returns-text');
+        // Validate response status and body
+        expect(response.statusCode).toEqual(500);
+        const body = response._getJSONData();
+        expect(body).toHaveProperty('status', 'error');
+        expect(body).not.toHaveProperty('category', 'INTERNAL_ERROR');
+        expect(body).toHaveProperty('message', 'internal error');
+        // Validate log output
+        expect(TEST_CONFIG.logger.warn).toHaveBeenCalledWith(expect.stringContaining('App function "returns-text" execution failed due to server internal error'));
+        expect(TEST_CONFIG.logger.error).toHaveBeenCalledWith(error);
+        // Validate process.env is put back to what it was before the call
+        expect(process.env).toEqual(JSON.parse(initialEnvJson));
+    });
+    it('logs to console from inside the function', async () => {
+        const log = vi.spyOn(console, 'log').mockImplementation(() => { });
+        const debug = vi.spyOn(console, 'debug').mockImplementation(() => { });
+        const info = vi.spyOn(console, 'info').mockImplementation(() => { });
+        const warn = vi.spyOn(console, 'warn').mockImplementation(() => { });
+        const error = vi.spyOn(console, 'error').mockImplementation(() => { });
+        // Act
+        const response = await callAppFunction('logs');
+        // Validate response status and body
+        expect(response.statusCode).toEqual(200);
+        expect(response._getJSONData()).toEqual({
+            logId: 'n/a',
+            response: { status: 'success' },
+        });
+        // Validate function logging
+        expect(log).toHaveBeenCalledTimes(1);
+        expect(log).toHaveBeenCalledWith('log line');
+        expect(debug).toHaveBeenCalledTimes(1);
+        expect(debug).toHaveBeenCalledWith('debug line');
+        expect(info).toHaveBeenCalledTimes(2);
+        expect(info).toHaveBeenNthCalledWith(1, 'info line');
+        expect(info).toHaveBeenNthCalledWith(2, 'print data:', [1, 2]);
+        expect(warn).toHaveBeenCalledTimes(1);
+        expect(warn).toHaveBeenCalledWith('warn line');
+        expect(error).toHaveBeenCalledTimes(1);
+        expect(error).toHaveBeenCalledWith('error line');
+        // Validate service logging, which is separate from function logging
+        expect(TEST_CONFIG.logger.debug).toHaveBeenCalledTimes(1);
+        expect(TEST_CONFIG.logger.debug).toHaveBeenNthCalledWith(1, expect.stringContaining('App function "logs" execution succeeded'));
+        expect(TEST_CONFIG.logger.warn).toHaveBeenCalledTimes(0);
+        expect(TEST_CONFIG.logger.error).toHaveBeenCalledTimes(0);
+        // Validate process.env is put back to what it was before the call
+        expect(process.env).toEqual(JSON.parse(initialEnvJson));
+    });
+});

package/dist/lib/__tests__/app-functions/services/services_v20232.spec.d.ts

@@ -0,0 +1 @@
+export {};