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

package/dist/lib/__tests__/{app-functions/services → proxy}/AppProxyService.spec.js

@@ -1,10 +1,13 @@
 import { describe, it, expect, vi, afterEach, beforeEach } from 'vitest';
-import { extractErrorData, mapToLocalUrl, AppProxyService, } from "../../../app-functions/services/AppProxyService.js";
-import { axiosErrorMappings, defaultServerError, validationError, } from "../../../app-functions/constants.js";
+vi.mock('../../errorReporter.ts', () => ({
+    reportError: vi.fn(),
+}));
+import { extractErrorData, mapToLocalUrl, AppProxyService, } from "../../proxy/AppProxyService.js";
+import { axiosErrorMappings, defaultServerError, validationError, } from "../../proxy/constants.js";
 import axios, { AxiosError, HttpStatusCode } from 'axios';
 import httpMocks from 'node-mocks-http';
 import { EventEmitter } from 'node:events';
-import * as signing from "../../../app-functions/signing.js";
+import * as signing from "../../proxy/signing.js";
 const callAppProxy = async ({ requestUri, method, requestTimeoutMillis, requestBody, requestHeaders, accountId, localDevUrlMapping = {}, logger, }) => {
     const request = httpMocks.createRequest({
         method: 'POST',
@@ -79,6 +82,20 @@ describe('AppProxyService', () => {
                 [validUrl]: newValidUrl,
             }, validUrlWithBasePath, [], logger)).toBe(`${newValidUrl}${basePath}`);
         });
+        it('should preserve the local mapping sub-path when merging URLs', () => {
+            const newValidUrl = 'https://localhost:3000/api/v1';
+            const requestPath = '/some/endpoint';
+            expect(mapToLocalUrl({
+                [validUrl]: newValidUrl,
+            }, `${validUrl}${requestPath}`, [], logger)).toBe(`${newValidUrl}${requestPath}`);
+        });
+        it('should preserve the local mapping sub-path with trailing slash when merging URLs', () => {
+            const newValidUrl = 'https://localhost:3000/api/v1/';
+            const requestPath = '/some/endpoint';
+            expect(mapToLocalUrl({
+                [validUrl]: newValidUrl,
+            }, `${validUrl}${requestPath}`, [], logger)).toBe(`https://localhost:3000/api/v1${requestPath}`);
+        });
         it('should honor urls with ports', () => {
             const newValidUrl = 'https://localhost:5173';
             expect(mapToLocalUrl({
@@ -343,6 +360,8 @@ describe('AppProxyService', () => {
                     requestUri: [requestUri],
                 }),
             }));
+            expect(logger.warn).toHaveBeenCalledWith(expect.stringContaining(`returned HTTP ${statusCode}`));
+            expect(logger.info).toHaveBeenCalledWith(expect.stringContaining('Request failed'));
         });
         it('returns success responses with error info in the body if the proxy returns 4xx, mimicking the backend proxy behavior', async () => {
             const responseBody = { message: 'this is 404z' };
@@ -380,6 +399,7 @@ describe('AppProxyService', () => {
                     requestUri: [requestUri],
                 }),
             }));
+            expect(logger.warn).toHaveBeenCalledWith(expect.stringContaining(`returned HTTP ${statusCode}`));
         });
         it('returns success responses with error info in the body if the proxy returns 5xx, mimicking the backend proxy behavior', async () => {
             const responseBody = { message: 'there is 500' };
@@ -417,6 +437,56 @@ describe('AppProxyService', () => {
                     requestUri: [requestUri],
                 }),
             }));
+            expect(logger.warn).toHaveBeenCalledWith(expect.stringContaining(`returned HTTP ${statusCode}`));
+        });
+        it('should log an error when the proxy cannot reach the backend (e.g. ECONNREFUSED)', async () => {
+            const method = 'GET';
+            const requestUri = 'http://localhost:9999';
+            const accountId = 123456;
+            const requestTimeoutMillis = 1000;
+            // @ts-expect-error Typescript doesn't know this is a spy
+            axios.request.mockImplementationOnce(() => Promise.reject(new AxiosError('connect ECONNREFUSED 127.0.0.1:9999', AxiosError.ERR_NETWORK)));
+            await callAppProxy({
+                requestUri,
+                method,
+                requestTimeoutMillis,
+                accountId,
+                logger,
+            });
+            expect(logger.error).toHaveBeenCalledWith(expect.stringContaining('connect ECONNREFUSED'));
+            expect(logger.info).toHaveBeenCalledWith(expect.stringContaining('Request failed'));
+        });
+        it('should log an error when TLS verification fails', async () => {
+            const method = 'GET';
+            const requestUri = 'https://localhost:1235';
+            const accountId = 123456;
+            const requestTimeoutMillis = 1000;
+            // @ts-expect-error Typescript doesn't know this is a spy
+            axios.request.mockImplementationOnce(() => Promise.reject(new AxiosError('unable to verify the first certificate', AxiosError.ERR_NETWORK)));
+            await callAppProxy({
+                requestUri,
+                method,
+                requestTimeoutMillis,
+                accountId,
+                logger,
+            });
+            expect(logger.error).toHaveBeenCalledWith(expect.stringContaining('unable to verify the first certificate'));
+        });
+        it('should log an error for non-Axios errors', async () => {
+            const method = 'GET';
+            const requestUri = 'http://localhost:1234';
+            const accountId = 123456;
+            const requestTimeoutMillis = 1000;
+            // @ts-expect-error Typescript doesn't know this is a spy
+            axios.request.mockImplementationOnce(() => Promise.reject(new TypeError('Cannot read properties of undefined')));
+            await callAppProxy({
+                requestUri,
+                method,
+                requestTimeoutMillis,
+                accountId,
+                logger,
+            });
+            expect(logger.error).toHaveBeenCalledWith(expect.stringContaining('Cannot read properties of undefined'));
         });
         describe('with local.json mapping', () => {
             const mappedUrl = 'http://localhost:1234';

package/dist/lib/__tests__/{app-functions → proxy}/signing.spec.js

@@ -1,6 +1,6 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import { Signature } from '@hubspot/api-client';
-import { getSignatureHeaders, sign, formatForSigning, } from "../../app-functions/signing.js";
+import { getSignatureHeaders, sign, formatForSigning, } from "../../proxy/signing.js";
 /**
  * Validate signing of requests for headers
  */

package/dist/lib/__tests__/server.spec.js

@@ -1,13 +1,16 @@
 import { afterEach, describe, it, expect, vi, beforeEach } from 'vitest';
-import * as devServer from "../app-functions/services/index.js";
+import * as serverlessServices from "../serverless/services/AppFunctionExecutionService.js";
+import * as proxyService from "../proxy/AppProxyService.js";
 import startDevServer from "../server.js";
 import { DevServerState } from "../DevServerState.js";
 import { createMockLogger, createDevServerConfig, createMockViteDevServer, } from "./factories.js";
 const useMock = vi.fn();
-vi.mock('../app-functions/services/index.ts', () => ({
-    AppProxyService: vi.fn(() => vi.fn((req, res, next) => next())),
+vi.mock('../serverless/services/AppFunctionExecutionService.ts', () => ({
     AppFunctionExecutionService: vi.fn(() => vi.fn((req, res, next) => next())),
 }));
+vi.mock('../proxy/AppProxyService.ts', () => ({
+    AppProxyService: vi.fn(() => vi.fn((req, res, next) => next())),
+}));
 vi.mock('express', () => {
     const expressMock = () => ({
         use: useMock,
@@ -43,8 +46,8 @@ describe('server', () => {
     describe('startDevServer', () => {
         beforeEach(() => {
             useMock.mockClear();
-            vi.mocked(devServer.AppFunctionExecutionService).mockReturnValue(vi.fn());
-            vi.mocked(devServer.AppProxyService).mockReturnValue(vi.fn());
+            vi.mocked(serverlessServices.AppFunctionExecutionService).mockReturnValue(vi.fn());
+            vi.mocked(proxyService.AppProxyService).mockReturnValue(vi.fn());
             vi.clearAllMocks();
         });
         it('should add the AppProxyService middleware when localDevUrlMapping is provided', async () => {
@@ -61,8 +64,8 @@ describe('server', () => {
             expect(useMock).toHaveBeenNthCalledWith(3, '/api/crm-extensibility/execution/internal/v3', expect.any(Function), 
             // This is the AppProxyService middleware
             expect.any(Function));
-            expect(devServer.AppProxyService).toHaveBeenCalledTimes(1);
-            expect(devServer.AppProxyService).toHaveBeenCalledWith({
+            expect(proxyService.AppProxyService).toHaveBeenCalledTimes(1);
+            expect(proxyService.AppProxyService).toHaveBeenCalledWith({
                 accountId: devServerConfig.accountId,
                 allowedUrls: [],
                 localDevUrlMapping: devServerState.localDevUrlMapping,
@@ -79,7 +82,7 @@ describe('server', () => {
                 viteDevServer: createMockViteDevServer(),
             });
             expect(useMock).toHaveBeenNthCalledWith(3, '/api/crm-extensibility/execution/internal/v3', expect.any(Function));
-            expect(devServer.AppProxyService).toHaveBeenCalledTimes(0);
+            expect(proxyService.AppProxyService).toHaveBeenCalledTimes(0);
         });
         it('should not add the AppProxyService middleware when localDevUrlMapping is not provided', async () => {
             const devServerState = new DevServerState({
@@ -91,7 +94,7 @@ describe('server', () => {
                 viteDevServer: createMockViteDevServer(),
             });
             expect(useMock).toHaveBeenNthCalledWith(3, '/api/crm-extensibility/execution/internal/v3', expect.any(Function));
-            expect(devServer.AppProxyService).toHaveBeenCalledTimes(0);
+            expect(proxyService.AppProxyService).toHaveBeenCalledTimes(0);
         });
         it('should add the AppFunctionExecutionService middleware if is a private app', async () => {
             const devServerState = new DevServerState({
@@ -104,7 +107,7 @@ describe('server', () => {
                 devServerState,
                 viteDevServer: createMockViteDevServer(),
             });
-            expect(devServer.AppFunctionExecutionService).toHaveBeenCalledTimes(1);
+            expect(serverlessServices.AppFunctionExecutionService).toHaveBeenCalledTimes(1);
         });
         it('should not add the AppFunctionExecutionService middleware if is a public app', async () => {
             const devServerState = new DevServerState({
@@ -118,7 +121,7 @@ describe('server', () => {
                 devServerState,
                 viteDevServer: createMockViteDevServer(),
             });
-            expect(devServer.AppFunctionExecutionService).not.toHaveBeenCalled();
+            expect(serverlessServices.AppFunctionExecutionService).not.toHaveBeenCalled();
         });
         it('should return httpServer and shutdown function', async () => {
             const devServerState = new DevServerState(devServerConfig);

package/dist/lib/__tests__/serverless/config.spec.js

@@ -0,0 +1,61 @@
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import fs from 'node:fs';
+import { loadMultiFunctionInfo } from "../../serverless/config.js";
+import { TEST_CONFIG_V202603 as TEST_CONFIG } from "./fixtures/constants.js";
+describe('loadMultiFunctionInfo (v2026.03)', () => {
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('loads app functions from hsmeta files', () => {
+        const result = loadMultiFunctionInfo(TEST_CONFIG);
+        expect(result.appFunctions).toHaveProperty('returns-text');
+        expect(result.appFunctions['returns-text']).toEqual({
+            file: 'func-returns-text.cjs',
+            secrets: [],
+        });
+        expect(Object.keys(result.appFunctions).length).toBeGreaterThan(0);
+    });
+    it('skips hsmeta files that cannot be read', () => {
+        const originalReadFileSync = fs.readFileSync;
+        vi.spyOn(fs, 'readFileSync').mockImplementation((...args) => {
+            const filePath = args[0];
+            if (typeof filePath === 'string' &&
+                filePath.endsWith('returns-text-hsmeta.json')) {
+                throw new Error('ENOENT: no such file or directory');
+            }
+            return originalReadFileSync.apply(fs, args);
+        });
+        const result = loadMultiFunctionInfo(TEST_CONFIG);
+        expect(result.appFunctions).not.toHaveProperty('returns-text');
+        expect(TEST_CONFIG.logger.warn).toHaveBeenCalledWith(expect.stringContaining('Failed to read or parse'));
+        expect(TEST_CONFIG.logger.warn).toHaveBeenCalledWith(expect.stringContaining('returns-text-hsmeta.json'));
+    });
+    it('skips hsmeta files with invalid JSON', () => {
+        const originalReadFileSync = fs.readFileSync;
+        vi.spyOn(fs, 'readFileSync').mockImplementation((...args) => {
+            const filePath = args[0];
+            if (typeof filePath === 'string' &&
+                filePath.endsWith('returns-text-hsmeta.json')) {
+                return 'not-valid-json';
+            }
+            return originalReadFileSync.apply(fs, args);
+        });
+        const result = loadMultiFunctionInfo(TEST_CONFIG);
+        expect(result.appFunctions).not.toHaveProperty('returns-text');
+        expect(TEST_CONFIG.logger.warn).toHaveBeenCalledWith(expect.stringContaining('Failed to read or parse'));
+    });
+    it('still loads other functions when one hsmeta file fails', () => {
+        const originalReadFileSync = fs.readFileSync;
+        vi.spyOn(fs, 'readFileSync').mockImplementation((...args) => {
+            const filePath = args[0];
+            if (typeof filePath === 'string' &&
+                filePath.endsWith('returns-text-hsmeta.json')) {
+                throw new Error('ENOENT: no such file or directory');
+            }
+            return originalReadFileSync.apply(fs, args);
+        });
+        const result = loadMultiFunctionInfo(TEST_CONFIG);
+        expect(result.appFunctions).not.toHaveProperty('returns-text');
+        expect(Object.keys(result.appFunctions).length).toBeGreaterThan(0);
+    });
+});

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

@@ -1,7 +1,7 @@
 import { describe, it, expect, vi, afterEach } from 'vitest';
 import { Client } from '@hubspot/api-client';
-import { fetchObjectContext } from "../../app-functions/context.js";
-import { SAMPLE_BAD_REQUEST_API_ERROR, SAMPLE_NOT_FOUND_API_ERROR, SAMPLE_UNAUTHORIZED_API_ERROR, TEST_CONFIG_V20231 as TEST_CONFIG, } from "./fixtures/constants.js";
+import { fetchObjectContext } from "../../serverless/context.js";
+import { SAMPLE_BAD_REQUEST_API_ERROR, SAMPLE_NOT_FOUND_API_ERROR, SAMPLE_UNAUTHORIZED_API_ERROR, TEST_CONFIG_V20251 as TEST_CONFIG, } from "./fixtures/constants.js";
 /**
  * Validate construction of the context (first argument in an app function)
  */

package/dist/lib/__tests__/serverless/executor_unsupported.spec.js

@@ -0,0 +1,37 @@
+import { describe, it, expect, vi, afterEach, beforeEach } from 'vitest';
+import { Client } from '@hubspot/api-client';
+import { executeFunction } from "../../serverless/executor.js";
+import { Reason, ExecutionError } from "../../serverless/errors.js";
+import { PLATFORM_VERSION } from "../../constants.js";
+import { buildUnsupportedVersionConfig } from "./fixtures/constants.js";
+describe('app function executor - unsupported platform versions', () => {
+    const initialEnvJson = JSON.stringify(process.env);
+    beforeEach(() => {
+        vi.spyOn(Client.prototype, 'crm', 'get').mockReturnValue({
+            objects: {
+                basicApi: {
+                    getById: () => 
+                    // @ts-ignore
+                    Promise.resolve({
+                        properties: { firstname: 'First', lastname: 'Last' },
+                    }),
+                },
+            },
+        });
+    });
+    afterEach(() => {
+        vi.resetAllMocks();
+        process.env = JSON.parse(initialEnvJson);
+    });
+    it.each([['V20252', PLATFORM_VERSION.V20252]])('should reject with UnsupportedVersion for %s', async (_label, platformVersion) => {
+        const config = buildUnsupportedVersionConfig(platformVersion);
+        try {
+            await executeFunction(config, 'returns-text', {}, () => { });
+            expect.unreachable('should have thrown');
+        }
+        catch (err) {
+            expect(err).toBeInstanceOf(ExecutionError);
+            expect(err.reason).toBe(Reason.UnsupportedVersion);
+        }
+    });
+});

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

@@ -1,14 +1,10 @@
 import { describe, it, expect, vi, afterEach, beforeEach } from 'vitest';
 import { Client } from '@hubspot/api-client';
-import { Reason, ExecutionError } from "../../app-functions/errors.js";
-import { executeFunction } from "../../app-functions/executor.js";
-import * as SecretsModule from "../../app-functions/secrets.js";
-import { NOOP_CALLBACK, TEST_CONFIG_V20232 as TEST_CONFIG, } from "./fixtures/constants.js";
-/**
- * Validate function execution using sample functions defined in
- * the app path of TEST_CONFIG, which is fixtures/app.functions/
- */
-describe(`app function executor`, () => {
+import { Reason, ExecutionError } from "../../serverless/errors.js";
+import { executeFunction } from "../../serverless/executor.js";
+import * as SecretsModule from "../../serverless/secrets.js";
+import { NOOP_CALLBACK, TEST_CONFIG_V20251 as TEST_CONFIG, } from "./fixtures/constants.js";
+describe(`app function executor (v2025.1)`, () => {
     let actual;
     const initialEnvJson = JSON.stringify(process.env);
     const setActual = (value) => {
@@ -16,12 +12,10 @@ describe(`app function executor`, () => {
     };
     beforeEach(() => {
         setActual(undefined);
-        // mock `apiClient.crm.objects.basicApi.getById` to return propertiesToSend for the CRM object
         vi.spyOn(Client.prototype, 'crm', 'get').mockReturnValue({
             objects: {
                 basicApi: {
                     getById: () => 
-                    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
                     // @ts-ignore
                     Promise.resolve({
                         properties: { firstname: 'First', lastname: 'Last' },
@@ -32,7 +26,6 @@ describe(`app function executor`, () => {
     });
     afterEach(() => {
         vi.resetAllMocks();
-        // restore process.env
         process.env = JSON.parse(initialEnvJson);
     });
     it('executes a function', async () => {
@@ -176,7 +169,7 @@ describe(`app function executor`, () => {
             expect(err.cause).toHaveProperty('message', 'Oops');
         }
     });
-    it('throws an error if the function calls callback (only 2023.2)', async () => {
+    it('throws an error if the function calls callback', async () => {
         try {
             await executeFunction(TEST_CONFIG, 'calls-callback', {}, NOOP_CALLBACK);
         }

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

@@ -1,13 +1,10 @@
 import { describe, it, expect, vi, afterEach, beforeEach } from 'vitest';
 import { Client } from '@hubspot/api-client';
-import { Reason, ExecutionError } from "../../app-functions/errors.js";
-import { executeFunction } from "../../app-functions/executor.js";
-import { NOOP_CALLBACK, TEST_CONFIG_V20231 as TEST_CONFIG, } from "./fixtures/constants.js";
-/**
- * Validate function execution using sample functions defined in
- * the app path of TEST_CONFIG, which is fixtures/app.functions/
- */
-describe('app function executor', () => {
+import { Reason, ExecutionError } from "../../serverless/errors.js";
+import { executeFunction } from "../../serverless/executor.js";
+import * as SecretsModule from "../../serverless/secrets.js";
+import { NOOP_CALLBACK, TEST_CONFIG_V202603 as TEST_CONFIG, } from "./fixtures/constants.js";
+describe(`app function executor (v2026.03)`, () => {
     let actual;
     const initialEnvJson = JSON.stringify(process.env);
     const setActual = (value) => {
@@ -15,12 +12,10 @@ describe('app function executor', () => {
     };
     beforeEach(() => {
         setActual(undefined);
-        // mock `apiClient.crm.objects.basicApi.getById` to return propertiesToSend for the CRM object
         vi.spyOn(Client.prototype, 'crm', 'get').mockReturnValue({
             objects: {
                 basicApi: {
                     getById: () => 
-                    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
                     // @ts-ignore
                     Promise.resolve({
                         properties: { firstname: 'First', lastname: 'Last' },
@@ -31,7 +26,6 @@ describe('app function executor', () => {
     });
     afterEach(() => {
         vi.resetAllMocks();
-        // restore process.env
         process.env = JSON.parse(initialEnvJson);
     });
     it('executes a function', async () => {
@@ -90,19 +84,29 @@ describe('app function executor', () => {
     });
     describe('handles secrets', () => {
         it('supplies secrets including the private app access token', async () => {
+            const setProperTokenInSecretsSpy = vi.spyOn(SecretsModule, 'setProperTokenInSecrets');
+            const loadSecretsSpy = vi.spyOn(SecretsModule, 'loadSecrets');
             await executeFunction(TEST_CONFIG, 'uses-secret', {}, setActual);
             expect(actual).toEqual({
                 contextSecrets: 'Listen up: ',
                 processEnvs: 'Listen up: Good dog!',
             });
+            expect(setProperTokenInSecretsSpy).toHaveBeenCalledTimes(1);
+            expect(loadSecretsSpy).toHaveBeenCalledTimes(1);
+            setProperTokenInSecretsSpy.mockRestore();
+            loadSecretsSpy.mockRestore();
         });
         it('works with other inputs', async () => {
+            const setProperTokenInSecretsSpy = vi.spyOn(SecretsModule, 'setProperTokenInSecrets');
+            const loadSecretsSpy = vi.spyOn(SecretsModule, 'loadSecrets');
             const inputs = { parameters: { PHRASE: 'Bella, ' } };
             await executeFunction(TEST_CONFIG, 'uses-secret', inputs, setActual);
             expect(actual).toEqual({
                 contextSecrets: 'Listen up: Bella, ',
                 processEnvs: 'Listen up: Bella, Good dog!',
             });
+            setProperTokenInSecretsSpy.mockRestore();
+            loadSecretsSpy.mockRestore();
         });
     });
     it('throws an error if the function is not declared', async () => {
@@ -165,4 +169,15 @@ describe('app function executor', () => {
             expect(err.cause).toHaveProperty('message', 'Oops');
         }
     });
+    it('throws an error if the function calls callback', async () => {
+        try {
+            await executeFunction(TEST_CONFIG, 'calls-callback', {}, NOOP_CALLBACK);
+        }
+        catch (err) {
+            expect(err).toBeInstanceOf(ExecutionError);
+            expect(err.reason).toBe(Reason.UncaughtError);
+            expect(err.cause).toBeInstanceOf(Error);
+            expect(err.cause).toHaveProperty('message', 'callback is not a function');
+        }
+    });
 });

package/dist/lib/__tests__/{app-functions → serverless}/fixtures/constants.d.ts

@@ -1,6 +1,7 @@
-import { ApiException, ServiceConfiguration } from '../../../app-functions/types.ts';
-export declare const TEST_CONFIG_V20231: ServiceConfiguration;
-export declare const TEST_CONFIG_V20232: ServiceConfiguration;
+import { ApiException, PlatformVersion, ServiceConfiguration } from '../../../serverless/types.ts';
+export declare const TEST_CONFIG_V20251: ServiceConfiguration;
+export declare const TEST_CONFIG_V202603: ServiceConfiguration;
+export declare function buildUnsupportedVersionConfig(platformVersion: PlatformVersion): ServiceConfiguration;
 export declare const NOOP_CALLBACK: () => void;
 export declare const SAMPLE_FUNCTION_JS = "exports.main = (context = {}, sendResponse) => {\n  sendResponse({\n    propertiesToSend: context.propertiesToSend,\n    parameters: context.parameters,\n    payload: context.event && context.event.payload,\n    secrets: context.secrets,\n  });\n};\n";
 export declare const SAMPLE_SERVERLESS_JSON: {

package/dist/lib/__tests__/{app-functions → serverless}/fixtures/constants.js

@@ -1,5 +1,5 @@
 import { vi } from 'vitest';
-import { PLATFORM_VERSION } from "../../../app-functions/constants.js";
+import { PLATFORM_VERSION } from "../../../constants.js";
 import path from 'node:path';
 function buildTestConfig(platformVersion) {
     return {
@@ -17,8 +17,14 @@ function buildTestConfig(platformVersion) {
         platformVersion,
     };
 }
-export const TEST_CONFIG_V20231 = buildTestConfig(PLATFORM_VERSION.V20231);
-export const TEST_CONFIG_V20232 = buildTestConfig(PLATFORM_VERSION.V20232);
+export const TEST_CONFIG_V20251 = buildTestConfig(PLATFORM_VERSION.V20251);
+export const TEST_CONFIG_V202603 = buildTestConfig(PLATFORM_VERSION.V202603);
+export function buildUnsupportedVersionConfig(platformVersion) {
+    return {
+        ...buildTestConfig(PLATFORM_VERSION.V20251),
+        platformVersion,
+    };
+}
 export const NOOP_CALLBACK = () => { };
 export const SAMPLE_FUNCTION_JS = `exports.main = (context = {}, sendResponse) => {
   sendResponse({

package/dist/lib/__tests__/serverless/fixtures/v2026.03/functions/func-async-fails.cjs

@@ -0,0 +1,5 @@
+"use strict";
+exports.main = async (__context = {}) => {
+    const { data } = await Promise.reject(new Error('fail'));
+    return data;
+};

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

@@ -0,0 +1 @@
+export function main(__context?: {}): Promise<never>;

package/dist/lib/__tests__/serverless/fixtures/v2026.03/functions/func-async-succeeds.cjs

@@ -0,0 +1,5 @@
+"use strict";
+exports.main = async (__context = {}) => {
+    const { data } = await Promise.resolve({ data: { result: 'simulated' } });
+    return data;
+};

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

@@ -0,0 +1,3 @@
+export function main(__context?: {}): Promise<{
+    result: string;
+}>;

package/dist/lib/__tests__/serverless/fixtures/v2026.03/functions/func-does-not-export-main.cjs

@@ -0,0 +1,4 @@
+"use strict";
+exports.notMain = (__context = {}) => {
+    return 'result';
+};

package/dist/lib/__tests__/serverless/fixtures/v2026.03/functions/func-does-not-export-main.d.cts

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

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

@@ -1,8 +1,8 @@
 "use strict";
-exports.main = (context = {}, callback) => {
-    callback({
+exports.main = (context = {}) => {
+    return {
         propertiesToSend: context.propertiesToSend,
         parameters: context.parameters,
         payload: context.event && context.event.payload,
-    });
+    };
 };

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

@@ -0,0 +1,5 @@
+export function main(context?: {}): {
+    propertiesToSend: any;
+    parameters: any;
+    payload: any;
+};

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

@@ -1,10 +1,10 @@
 "use strict";
-exports.main = (__context = {}, callback) => {
+exports.main = (__context = {}) => {
     console.log('log line');
     console.debug('debug line');
     console.info('info line');
     console.warn('warn line');
     console.error('error line');
     console.info('print data:', [1, 2]);
-    callback({ status: 'success' });
+    return { status: 'success' };
 };

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

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

package/dist/lib/__tests__/serverless/fixtures/v2026.03/functions/func-returns-function.cjs

@@ -0,0 +1,4 @@
+"use strict";
+exports.main = (__context = {}) => {
+    return () => { };
+};

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

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

package/dist/lib/__tests__/serverless/fixtures/v2026.03/functions/func-returns-implicitly.cjs

@@ -0,0 +1,7 @@
+"use strict";
+exports.main = async (__context = {}) => {
+    await Promise.resolve({ data: { result: 'simulated' } })
+        .then((res) => res.data)
+        .catch((err) => ({ error: `${err}` }));
+    // Implicitly returning 'undefined'
+};

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

@@ -0,0 +1 @@
+export function main(__context?: {}): Promise<void>;

package/dist/lib/__tests__/serverless/fixtures/v2026.03/functions/func-returns-promise-rejected.cjs

@@ -0,0 +1,4 @@
+"use strict";
+exports.main = (__context = {}) => {
+    return Promise.reject(new Error('fail')).then((res) => res.data);
+};

package/dist/lib/__tests__/serverless/fixtures/v2026.03/functions/func-returns-promise-rejected.d.cts

@@ -0,0 +1 @@
+export function main(__context?: {}): Promise<any>;

package/dist/lib/__tests__/serverless/fixtures/v2026.03/functions/func-returns-promise-resolved.cjs

@@ -0,0 +1,4 @@
+"use strict";
+exports.main = (__context = {}) => {
+    return Promise.resolve({ data: { result: 'simulated' } }).then((res) => res.data);
+};

package/dist/lib/__tests__/serverless/fixtures/v2026.03/functions/func-returns-promise-resolved.d.cts

@@ -0,0 +1,3 @@
+export function main(__context?: {}): Promise<{
+    result: string;
+}>;

package/dist/lib/__tests__/serverless/fixtures/v2026.03/functions/func-returns-text.cjs

@@ -0,0 +1,4 @@
+"use strict";
+exports.main = (__context = {}) => {
+    return 'result';
+};

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

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

package/dist/lib/__tests__/serverless/fixtures/v2026.03/functions/func-returns-undefined.cjs

@@ -0,0 +1,4 @@
+"use strict";
+exports.main = (__context = {}) => {
+    return undefined;
+};

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

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

package/dist/lib/__tests__/serverless/fixtures/v2026.03/functions/func-times-out.cjs

@@ -0,0 +1,12 @@
+"use strict";
+exports.main = (context = {}) => {
+    const parameters = context.parameters || {};
+    const delayMs = parameters.delayMs || 60_000;
+    const startedAt = Date.now();
+    return new Promise((resolve, __reject) => {
+        setTimeout(() => resolve({
+            status: 'success',
+            elapsedMs: Date.now() - startedAt,
+        }), delayMs);
+    });
+};

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

@@ -0,0 +1 @@
+export function main(context?: {}): Promise<any>;

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

@@ -0,0 +1,4 @@
+"use strict";
+exports.main = (__context = {}) => {
+    return 'This function is not declared in serverless.json';
+};