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

package/dist/lib/__tests__/serverless/fixtures/v2026.03/functions/func-undeclared.d.cts

@@ -0,0 +1 @@
+export function main(__context?: {}): string;

package/dist/lib/__tests__/{app-functions/fixtures/v2023.1/app.functions → serverless/fixtures/v2026.03/functions}/func-uses-secret.cjs

@@ -1,5 +1,5 @@
 "use strict";
-exports.main = (context = {}, callback) => {
+exports.main = (context = {}) => {
     const parameters = context.parameters || {};
     const paramPhrase = parameters['PHRASE'] || '';
     const secrets = context.secrets || {};
@@ -7,8 +7,8 @@ exports.main = (context = {}, callback) => {
     const secretPhrase = secrets['PHRASE'] || '';
     const envToken = process.env['PRIVATE_APP_ACCESS_TOKEN'] || '';
     const envPhrase = process.env['PHRASE'] || '';
-    callback({
+    return {
         contextSecrets: `${secretToken}${paramPhrase}${secretPhrase}`,
         processEnvs: `${envToken}${paramPhrase}${envPhrase}`,
-    });
+    };
 };

package/dist/lib/__tests__/serverless/fixtures/v2026.03/functions/func-uses-secret.d.cts

@@ -0,0 +1,4 @@
+export function main(context?: {}): {
+    contextSecrets: string;
+    processEnvs: string;
+};

package/dist/lib/__tests__/{app-functions → serverless}/secrets.spec.js

@@ -1,9 +1,9 @@
 import { describe, it, beforeEach, expect, vi, afterEach } from 'vitest';
 import { vol } from 'memfs';
-import { loadSecrets, setProperTokenInSecrets, } from "../../app-functions/secrets.js";
-import { APP_FUNCTIONS_MANIFEST_FILENAME, PRIVATE_APP_ACCESS_TOKEN, } from "../../app-functions/constants.js";
+import { loadSecrets, setProperTokenInSecrets, } from "../../serverless/secrets.js";
+import { APP_FUNCTIONS_MANIFEST_FILENAME, PRIVATE_APP_ACCESS_TOKEN, } from "../../serverless/constants.js";
 import { SAMPLE_FUNCTION_JS, SAMPLE_SERVERLESS_JSON, } from "./fixtures/constants.js";
-import { PrivateAppUserTokenManager } from "../../app-functions/services/PrivateAppUserTokenManager.js";
+import { PrivateAppUserTokenManager } from "../../serverless/services/PrivateAppUserTokenManager.js";
 const SRC_DIR = '/path/to/app.functions';
 const FUNCTION_NAME = 'sample-function';
 const FUNCTION_FILENAME = `${FUNCTION_NAME}.cjs`;
@@ -32,7 +32,7 @@ vi.mock('node:fs/promises', async () => {
     const memfs = await import('memfs');
     return { default: memfs.fs.promises, ...memfs.fs.promises };
 });
-vi.mock('../../app-functions/errorReporter.ts', () => ({
+vi.mock('../../errorReporter.ts', () => ({
     reportError: vi.fn(),
 }));
 /**

package/dist/lib/__tests__/{app-functions → serverless}/services/PrivateAppUserTokenManager.spec.js

@@ -1,12 +1,12 @@
 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 { PrivateAppUserTokenManager } from "../../../serverless/services/PrivateAppUserTokenManager.js";
+import { fetchPrivateAppUserToken as __fetchPrivateAppUserToken, createPrivateAppUserToken as __createPrivateAppUserToken, updatePrivateAppUserToken as __updatePrivateAppUserToken, } from "../../../serverless/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";
+import { generateTokensEnableMessage, generateMissingScopesMessage, generateMissingScopesMoreContextMessage, } from "../../../serverless/services/messages.js";
 vi.mock('@hubspot/local-dev-lib/personalAccessKey');
-vi.mock('../../../app-functions/api/privateAppUserToken.ts');
+vi.mock('../../../serverless/api/privateAppUserToken.ts');
 const scopesOnAccessToken = __scopesOnAccessToken;
 const fetchPrivateAppUserToken = __fetchPrivateAppUserToken;
 const createPrivateAppUserToken = __createPrivateAppUserToken;

package/dist/lib/__tests__/serverless/services/services_v20251.spec.d.ts

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

package/dist/lib/__tests__/{app-functions/services/services_v20232.spec.js → serverless/services/services_v20251.spec.js}

@@ -1,13 +1,13 @@
 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_V20232 as TEST_CONFIG } from "../fixtures/constants.js";
-import * as executor from "../../../app-functions/executor.js";
+import { AppFunctionExecutionService } from "../../../serverless/services/AppFunctionExecutionService.js";
+import { TEST_CONFIG_V20251 as TEST_CONFIG } from "../fixtures/constants.js";
+import * as executor from "../../../serverless/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');
+import { USER_TOKEN_READ, USER_TOKEN_WRITE, } from "../../../serverless/services/constants.js";
+import { PrivateAppUserTokenManager } from "../../../serverless/services/PrivateAppUserTokenManager.js";
+vi.mock('../../../serverless/services/PrivateAppUserTokenManager.ts');
 vi.mock('@hubspot/local-dev-lib/personalAccessKey');
 const scopesOnAccessToken = __scopesOnAccessToken;
 const callAppFunction = async (functionName, parameters) => {
@@ -37,16 +37,12 @@ const callAppFunction = async (functionName, parameters) => {
     await handler(request, response);
     return await responsePromised;
 };
-/**
- * Validate the service for executing app functions
- */
-describe('app function dev server', () => {
+describe('app function dev server (v2025.1)', () => {
     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();
@@ -54,167 +50,132 @@ describe('app function dev server', () => {
     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));
         });
     });
-    it('returns "200 OK" response if function returns implicitly (only 2023.2)', async () => {
+    it('returns "200 OK" response if function returns implicitly', async () => {
         const response = await callAppFunction('returns-implicitly');
-        // Validate response status and body
         expect(response.statusCode).toEqual(200);
         expect(response._getJSONData()).toEqual({
             logId: 'n/a',
             response: null,
         });
-        // Validate log output
         expect(TEST_CONFIG.logger.debug).toHaveBeenCalledWith(expect.stringContaining('App function "returns-implicitly" 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 = 10; // milliseconds
-        // Validate response status and body
+        const variance = 10;
         expect(response.statusCode).toEqual(200);
         const body = response._getJSONData();
         expect(body).toEqual({
@@ -223,27 +184,21 @@ describe('app function dev server', () => {
         });
         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 () => {
@@ -251,18 +206,14 @@ describe('app function dev server', () => {
         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 () => {
@@ -271,15 +222,12 @@ describe('app function dev server', () => {
         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);
@@ -291,12 +239,10 @@ describe('app function dev server', () => {
         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__/serverless/services/services_v202603.spec.d.ts

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