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

package/dist/lib/__tests__/app-functions/signing.spec.js

@@ -0,0 +1,460 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { Signature } from '@hubspot/api-client';
+import { getSignatureHeaders, sign, formatForSigning, } from "../../app-functions/signing.js";
+/**
+ * Validate signing of requests for headers
+ */
+describe('signing', () => {
+    // Changing this secret will change all the signatures
+    const clientSecret = '12345678-aaaa-bbbb-cccc-ddddeeeeffff';
+    const nullBody = null;
+    const undefinedBody = undefined;
+    const nanBody = NaN;
+    const infinityBody = Infinity;
+    const numberBody = 98765;
+    const zeroBody = 0;
+    const trueBody = true;
+    const falseBody = false;
+    const emptyStringBody = '';
+    const stringBody = 'testing body string';
+    const functionBody = () => { };
+    const setBody = new Set();
+    const mapBody = new Map();
+    const emptyObjectBody = {};
+    const emptyObjectStringBody = JSON.stringify(emptyObjectBody);
+    const objectBody = { a: 1, b: 2 };
+    const objectStringBody = JSON.stringify(objectBody);
+    const arrayBody = [{}, null, 2, { a: 'b', c: 4 }, ['e', false], undefined, 4];
+    const arrayStringBody = JSON.stringify(arrayBody);
+    const emptyV2Signature = '99080134002180aee8d0884d21ad51288c43b57e9953e4db1e3757999b35c392';
+    const emptyV3Signature = 'zTfXjo07jfzGouo4wvyAj3qEMUTVJ0PPYPACrluQtQI=';
+    const objectV2Signature = 'bc131b34cd63dafbbd2e969e87167311f5f6c0cd543c90fe84c73496093cf4a2';
+    const objectV3Signature = 'aaknaCGCYJ4yqzuf1UKGqAWUfdcilJtm5nc/ZCudR9k=';
+    const emptyObjectV2Signature = 'e955f4008c9f8bc80a14a00cb92fcc062d8df2023ddb39e135625f32764a1e78';
+    const emptyObjectV3Signature = 'bRPTUf7UOx1OqVAME6JSNfst9KxQYF5nRIUwG/KcQhQ=';
+    const options = {
+        // Changing this timestamp will change all the signatures
+        timestamp: 1111111111,
+        clientSecret,
+        requestBody: emptyStringBody,
+        url: 'https://hubspot.com/?appId=1&portalId=2&userId=3',
+        method: 'GET',
+        signature: '',
+    };
+    afterEach(() => {
+        vi.resetAllMocks();
+    });
+    describe('formatForSigning', () => {
+        it('returns an empty string for an empty string', () => { });
+        it('returns a json stringified string (double quoted)', () => {
+            expect(formatForSigning(stringBody)).toEqual('"testing body string"');
+        });
+        it('returns a stringified zero for zero body', () => {
+            expect(formatForSigning(zeroBody)).toEqual('0');
+        });
+        it('returns a stringified number', () => {
+            expect(formatForSigning(numberBody)).toEqual('98765');
+        });
+        it('returns empty string for null body', () => {
+            expect(formatForSigning(nullBody)).toEqual('');
+        });
+        it('returns empty string for undefined body', () => {
+            expect(formatForSigning(undefined)).toEqual('');
+        });
+        it('returns stringified "true" for true body', () => {
+            expect(formatForSigning(trueBody)).toEqual('true');
+        });
+        it('returns stringified "false" for false body', () => {
+            expect(formatForSigning(falseBody)).toEqual('false');
+        });
+        it('returns empty string for NaN body', () => {
+            expect(formatForSigning(nanBody)).toEqual('');
+        });
+        it('returns empty string for Infinity body', () => {
+            expect(formatForSigning(infinityBody)).toEqual('');
+        });
+        it('returns empty string for function body', () => {
+            expect(formatForSigning(functionBody)).toEqual('');
+        });
+        it('returns stringified object for for Set body', () => {
+            expect(formatForSigning(setBody)).toEqual(emptyObjectStringBody);
+        });
+        it('returns stringified object for for Map body', () => {
+            expect(formatForSigning(mapBody)).toEqual(emptyObjectStringBody);
+        });
+        it('returns stringified empty object for empty object body', () => {
+            expect(formatForSigning(emptyObjectBody)).toEqual(emptyObjectStringBody);
+        });
+        it('returns stringified object for object body', () => {
+            expect(formatForSigning(objectBody)).toEqual(objectStringBody);
+        });
+        it('returns stringified array with undefineds replaced with nulls for array body', () => {
+            expect(formatForSigning(arrayBody)).toEqual(arrayStringBody);
+        });
+    });
+    describe('sign.v2', () => {
+        it('creates a proper v2 signature with empty body', () => {
+            expect(sign.v2(options)).toEqual(emptyV2Signature);
+        });
+        it('creates a proper v2 signature with stringified object body', () => {
+            expect(sign.v2({ ...options, requestBody: objectStringBody })).toEqual(objectV2Signature);
+        });
+        it('creates a signature that matches what the backend created with a request body', () => {
+            const backendOptions = {
+                ...options,
+                clientSecret: 'f6e94c08-85d0-4608-bcc6-e1850176e7b8',
+                requestBody: 'REQUEST_BODY',
+                method: 'POST',
+                url: 'https://www.hubspot.com/webhook',
+            };
+            // https://git.hubteam.com/HubSpot/WebhooksPlatform/blob/f6737bea75d89b2bcbc565ace0ba78e60bcdd8f2/WebhooksPlatformSecurity/src/test/java/com/hubspot/webhooks/platform/security/WebhookSignatureGeneratorTest.java#L40
+            expect(sign.v2(backendOptions)).toEqual('57bb01a6e6ac92919b5e715d68f40265328701bbf1cf3fd73772887069945766');
+        });
+        it('creates a signature that matches what the backend created without a request body', () => {
+            const backendOptions = {
+                ...options,
+                clientSecret: 'f6e94c08-85d0-4608-bcc6-e1850176e7b8',
+                requestBody: '',
+                method: 'POST',
+                url: 'https://www.hubspot.com/webhook',
+            };
+            // https://git.hubteam.com/HubSpot/WebhooksPlatform/blob/f6737bea75d89b2bcbc565ace0ba78e60bcdd8f2/WebhooksPlatformSecurity/src/test/java/com/hubspot/webhooks/platform/security/WebhookSignatureGeneratorTest.java#L54
+            expect(sign.v2(backendOptions)).toEqual('befaef2b7354f11bf651f6468e8b5cf6bd449048deaf057f712980afb2a682f5');
+        });
+    });
+    describe('sign.v3', () => {
+        it('creates a proper v3 signature with empty body', () => {
+            expect(sign.v3(options)).toEqual(emptyV3Signature);
+        });
+        it('creates a proper v3 signature with stringified object body', () => {
+            expect(sign.v3({ ...options, requestBody: objectStringBody })).toEqual(objectV3Signature);
+        });
+        it('creates a signature that matches what the backend created with a request body', () => {
+            const backendOptions = {
+                ...options,
+                clientSecret: 'f6e94c08-85d0-4608-bcc6-e1850176e7b8',
+                requestBody: 'REQUEST_BODY',
+                method: 'POST',
+                url: 'https://www.hubspot.com/webhook',
+                timestamp: 1632188626483,
+            };
+            // https://git.hubteam.com/HubSpot/WebhooksPlatform/blob/f6737bea75d89b2bcbc565ace0ba78e60bcdd8f2/WebhooksPlatformSecurity/src/test/java/com/hubspot/webhooks/platform/security/WebhookSignatureGeneratorTest.java#L67
+            expect(sign.v3(backendOptions)).toEqual('jf872r5vscVcxCiDRHA4rGrqe/8BPLNVkdJSHdMnGTU=');
+        });
+        it('creates a signature that matches what the backend created without a request body', () => {
+            const backendOptions = {
+                ...options,
+                clientSecret: 'f6e94c08-85d0-4608-bcc6-e1850176e7b8',
+                requestBody: '',
+                method: 'POST',
+                url: 'https://www.hubspot.com/webhook',
+                timestamp: 1632188626483,
+            };
+            // https://git.hubteam.com/HubSpot/WebhooksPlatform/blob/f6737bea75d89b2bcbc565ace0ba78e60bcdd8f2/WebhooksPlatformSecurity/src/test/java/com/hubspot/webhooks/platform/security/WebhookSignatureGeneratorTest.java#L81
+            expect(sign.v3(backendOptions)).toEqual('csXgk7UbrE9F8ZmMvbpuKBxqIvTSqU1EX9pI/SJtxSE=');
+        });
+    });
+    describe('getSignatureHeaders', () => {
+        let savedEnv;
+        beforeEach(() => {
+            // Store current env because we will be modifying it
+            savedEnv = JSON.stringify(process.env);
+            process.env.CLIENT_SECRET = clientSecret;
+            vi.spyOn(Date.prototype, 'getTime').mockReturnValue(options.timestamp);
+            vi.spyOn(Date, 'now').mockReturnValue(options.timestamp);
+        });
+        afterEach(() => {
+            process.env = JSON.parse(savedEnv);
+        });
+        it('does not create any signature headers if process.env.CLIENT_SECRET is missing', () => {
+            expect(getSignatureHeaders({
+                method: options.method,
+                url: options.url,
+                requestBody: objectBody,
+            })).toEqual({
+                'X-HubSpot-Request-Timestamp': options.timestamp,
+                'X-HubSpot-Signature': objectV2Signature,
+                'X-HubSpot-Signature-Version': 'v2',
+                'X-HubSpot-Signature-v3': objectV3Signature,
+            });
+            delete process.env.CLIENT_SECRET;
+            expect(getSignatureHeaders({
+                method: options.method,
+                url: options.url,
+                requestBody: objectBody,
+            })).toBeUndefined();
+        });
+        it('creates proper request headers for empty string body', () => {
+            const doubleQuotedEmptyStringV2Signature = '8a129cb0bc3d2a8d72634bdbcbbe6a26e321d21f1832ece8e969dc25f14f446a';
+            const doubleQuotedEmptyStringV3Signature = 'vHLaaF6kLUy1XOa7O6osWuzV3v9EaxhIs/mJQbODE6g=';
+            expect(getSignatureHeaders({
+                method: options.method,
+                url: options.url,
+                requestBody: emptyStringBody,
+            })).toEqual({
+                'X-HubSpot-Request-Timestamp': options.timestamp,
+                'X-HubSpot-Signature': doubleQuotedEmptyStringV2Signature,
+                'X-HubSpot-Signature-Version': 'v2',
+                'X-HubSpot-Signature-v3': doubleQuotedEmptyStringV3Signature,
+            });
+        });
+        it('creates proper request headers for string body', () => {
+            const doubleQuotedStringV2Signature = 'f47fe62f3ecf4db32766db490fea65cdb12bfc554e9562ce9ee94f787254661d';
+            const doubleQuotedStringV3Signature = 'q/dQ0wPPFe+wBtr3I7/6mPYSNG0pvqUGK4yhcso9If8=';
+            expect(getSignatureHeaders({
+                method: options.method,
+                url: options.url,
+                requestBody: stringBody,
+            })).toEqual({
+                'X-HubSpot-Request-Timestamp': options.timestamp,
+                'X-HubSpot-Signature': doubleQuotedStringV2Signature,
+                'X-HubSpot-Signature-Version': 'v2',
+                'X-HubSpot-Signature-v3': doubleQuotedStringV3Signature,
+            });
+        });
+        it('creates proper request headers for zero body', () => {
+            const zeroV2Signature = '6d9ffe0ceeb63d9b18df5e1d2ad1175b9e3e21d873cd630008dc7bd9da21bc5a';
+            const zeroV3Signature = 'mOIoJRulruf3So7ER2nIiWx3qai8GJHEJSYPaVJHuuc=';
+            expect(getSignatureHeaders({
+                method: options.method,
+                url: options.url,
+                requestBody: zeroBody,
+            })).toEqual({
+                'X-HubSpot-Request-Timestamp': options.timestamp,
+                'X-HubSpot-Signature': zeroV2Signature,
+                'X-HubSpot-Signature-Version': 'v2',
+                'X-HubSpot-Signature-v3': zeroV3Signature,
+            });
+        });
+        it('creates proper request headers for number body', () => {
+            const numberV2Signature = 'b467e410c49b405c2f4f1fe0902eb00d203f02a52c65eddfcc977d8c53a4f952';
+            const numberV3Signature = '5NPk47PxfF6GlSjdPs2+ElmetlE0HbWPcGjQK1LAJcs=';
+            expect(getSignatureHeaders({
+                method: options.method,
+                url: options.url,
+                requestBody: numberBody,
+            })).toEqual({
+                'X-HubSpot-Request-Timestamp': options.timestamp,
+                'X-HubSpot-Signature': numberV2Signature,
+                'X-HubSpot-Signature-Version': 'v2',
+                'X-HubSpot-Signature-v3': numberV3Signature,
+            });
+        });
+        it('creates proper request headers for null body', () => {
+            expect(getSignatureHeaders({
+                method: options.method,
+                url: options.url,
+                requestBody: nullBody,
+            })).toEqual({
+                'X-HubSpot-Request-Timestamp': options.timestamp,
+                'X-HubSpot-Signature': emptyV2Signature,
+                'X-HubSpot-Signature-Version': 'v2',
+                'X-HubSpot-Signature-v3': emptyV3Signature,
+            });
+        });
+        it('creates proper request headers for undefined body', () => {
+            expect(getSignatureHeaders({
+                method: options.method,
+                url: options.url,
+                requestBody: undefinedBody,
+            })).toEqual({
+                'X-HubSpot-Request-Timestamp': options.timestamp,
+                'X-HubSpot-Signature': emptyV2Signature,
+                'X-HubSpot-Signature-Version': 'v2',
+                'X-HubSpot-Signature-v3': emptyV3Signature,
+            });
+        });
+        it('creates proper request headers for true body', () => {
+            const trueV2Signature = 'f1a7b1161e7b8d57dcda323dea73a4436ab09dffeedfab0ae292e5c76a332142';
+            const trueV3Signature = 'HAsym0s8w+iAGklVfrkwWGPJQdazvSTxxn0U6UOm+fI=';
+            expect(getSignatureHeaders({
+                method: options.method,
+                url: options.url,
+                requestBody: trueBody,
+            })).toEqual({
+                'X-HubSpot-Request-Timestamp': options.timestamp,
+                'X-HubSpot-Signature': trueV2Signature,
+                'X-HubSpot-Signature-Version': 'v2',
+                'X-HubSpot-Signature-v3': trueV3Signature,
+            });
+        });
+        it('creates proper request headers for false body', () => {
+            const falseV2Signature = '6dff8314721fa2b9e388760a9520a32893b1540cbc6274367b2db42cfaa0473b';
+            const falseV3Signature = 'b4vAq63KKWYKqM3y/r1FuCGDzuSgWjMZ9POwBaqmAQs=';
+            expect(getSignatureHeaders({
+                method: options.method,
+                url: options.url,
+                requestBody: falseBody,
+            })).toEqual({
+                'X-HubSpot-Request-Timestamp': options.timestamp,
+                'X-HubSpot-Signature': falseV2Signature,
+                'X-HubSpot-Signature-Version': 'v2',
+                'X-HubSpot-Signature-v3': falseV3Signature,
+            });
+        });
+        it('creates proper request headers for NaN body', () => {
+            expect(getSignatureHeaders({
+                method: options.method,
+                url: options.url,
+                requestBody: nanBody,
+            })).toEqual({
+                'X-HubSpot-Request-Timestamp': options.timestamp,
+                'X-HubSpot-Signature': emptyV2Signature,
+                'X-HubSpot-Signature-Version': 'v2',
+                'X-HubSpot-Signature-v3': emptyV3Signature,
+            });
+        });
+        it('creates proper request headers for Infinity body', () => {
+            expect(getSignatureHeaders({
+                method: options.method,
+                url: options.url,
+                requestBody: infinityBody,
+            })).toEqual({
+                'X-HubSpot-Request-Timestamp': options.timestamp,
+                'X-HubSpot-Signature': emptyV2Signature,
+                'X-HubSpot-Signature-Version': 'v2',
+                'X-HubSpot-Signature-v3': emptyV3Signature,
+            });
+        });
+        it('creates proper request headers for function body', () => {
+            expect(getSignatureHeaders({
+                method: options.method,
+                url: options.url,
+                requestBody: functionBody,
+            })).toEqual({
+                'X-HubSpot-Request-Timestamp': options.timestamp,
+                'X-HubSpot-Signature': emptyV2Signature,
+                'X-HubSpot-Signature-Version': 'v2',
+                'X-HubSpot-Signature-v3': emptyV3Signature,
+            });
+        });
+        it('creates proper request headers for Set body', () => {
+            expect(getSignatureHeaders({
+                method: options.method,
+                url: options.url,
+                requestBody: setBody,
+            })).toEqual({
+                'X-HubSpot-Request-Timestamp': options.timestamp,
+                'X-HubSpot-Signature': emptyObjectV2Signature,
+                'X-HubSpot-Signature-Version': 'v2',
+                'X-HubSpot-Signature-v3': emptyObjectV3Signature,
+            });
+        });
+        it('creates proper request headers for Map body', () => {
+            expect(getSignatureHeaders({
+                method: options.method,
+                url: options.url,
+                requestBody: mapBody,
+            })).toEqual({
+                'X-HubSpot-Request-Timestamp': options.timestamp,
+                'X-HubSpot-Signature': emptyObjectV2Signature,
+                'X-HubSpot-Signature-Version': 'v2',
+                'X-HubSpot-Signature-v3': emptyObjectV3Signature,
+            });
+        });
+        it('creates proper request headers for empty object body', () => {
+            expect(getSignatureHeaders({
+                method: options.method,
+                url: options.url,
+                requestBody: emptyObjectBody,
+            })).toEqual({
+                'X-HubSpot-Request-Timestamp': options.timestamp,
+                'X-HubSpot-Signature': emptyObjectV2Signature,
+                'X-HubSpot-Signature-Version': 'v2',
+                'X-HubSpot-Signature-v3': emptyObjectV3Signature,
+            });
+        });
+        it('creates proper request headers for object body', () => {
+            expect(getSignatureHeaders({
+                method: options.method,
+                url: options.url,
+                requestBody: objectBody,
+            })).toEqual({
+                'X-HubSpot-Request-Timestamp': options.timestamp,
+                'X-HubSpot-Signature': objectV2Signature,
+                'X-HubSpot-Signature-Version': 'v2',
+                'X-HubSpot-Signature-v3': objectV3Signature,
+            });
+        });
+        it('creates proper request headers for array body', () => {
+            const arrayV2Signature = '7db684f2a4f85d0a10443e0fcb56439bbfe5cd3957321334ea612d4a222d12bb';
+            const arrayV3Signature = 'BbmvQxGycRrmC4kiTOSEFy6TL4g/kGX+U4mKQWbPgzg=';
+            expect(getSignatureHeaders({
+                method: options.method,
+                url: options.url,
+                requestBody: arrayBody,
+            })).toEqual({
+                'X-HubSpot-Request-Timestamp': options.timestamp,
+                'X-HubSpot-Signature': arrayV2Signature,
+                'X-HubSpot-Signature-Version': 'v2',
+                'X-HubSpot-Signature-v3': arrayV3Signature,
+            });
+        });
+    });
+    describe('getSignatureHeaders validated against hubspot api-client signing lib', () => {
+        let savedEnv;
+        beforeEach(() => {
+            // Store current env because we will be modifying it
+            savedEnv = JSON.stringify(process.env);
+            process.env.CLIENT_SECRET = clientSecret;
+            vi.spyOn(Date.prototype, 'getTime').mockReturnValue(options.timestamp);
+            vi.spyOn(Date, 'now').mockReturnValue(options.timestamp);
+        });
+        afterEach(() => {
+            process.env = JSON.parse(savedEnv);
+        });
+        [
+            nullBody,
+            undefinedBody,
+            nanBody,
+            infinityBody,
+            numberBody,
+            zeroBody,
+            trueBody,
+            falseBody,
+            emptyStringBody,
+            stringBody,
+            functionBody,
+            setBody,
+            mapBody,
+            emptyObjectBody,
+            emptyObjectStringBody,
+            objectBody,
+            objectStringBody,
+            arrayBody,
+            arrayStringBody,
+        ].forEach((requestBody) => {
+            it(`generates v2 signatures for \`${requestBody}\` body that validate with HubSpot's api-client`, () => {
+                const headers = getSignatureHeaders({
+                    url: options.url,
+                    method: options.method,
+                    requestBody,
+                });
+                expect(Signature.isValid({
+                    url: options.url,
+                    method: options.method,
+                    requestBody: formatForSigning(requestBody),
+                    clientSecret,
+                    signatureVersion: 'v2',
+                    signature: headers['X-HubSpot-Signature'],
+                })).toBe(true);
+            });
+            it(`generates v3 signatures for \`${requestBody}\` body that validate with HubSpot's api-client`, () => {
+                const headers = getSignatureHeaders({
+                    url: options.url,
+                    method: options.method,
+                    requestBody,
+                });
+                expect(Signature.isValid({
+                    url: options.url,
+                    method: options.method,
+                    requestBody: formatForSigning(requestBody),
+                    clientSecret,
+                    signatureVersion: 'v3',
+                    signature: headers['X-HubSpot-Signature-v3'],
+                    timestamp: headers['X-HubSpot-Request-Timestamp'],
+                })).toBe(true);
+            });
+        });
+    });
+});

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

@@ -1,10 +1,10 @@
 import { afterEach, describe, it, expect, vi, beforeEach } from 'vitest';
-import * as devServer from '@hubspot/app-functions-dev-server';
+import * as devServer from "../app-functions/services/index.js";
 import startDevServer from "../server.js";
 import { DevServerState } from "../DevServerState.js";
 import { createMockLogger, createDevServerConfig, createMockViteDevServer, } from "./factories.js";
 const useMock = vi.fn();
-vi.mock('@hubspot/app-functions-dev-server', () => ({
+vi.mock('../app-functions/services/index.ts', () => ({
     AppProxyService: vi.fn(() => vi.fn((req, res, next) => next())),
     AppFunctionExecutionService: vi.fn(() => vi.fn((req, res, next) => next())),
 }));
@@ -138,6 +138,28 @@ describe('server', () => {
             });
             expect(devServerState.extensionsWebSocket).toBeDefined();
         });
+        it('should broadcast shutdown messages before closing WebSocket', async () => {
+            const devServerState = new DevServerState(devServerConfig);
+            const { shutdown } = await startDevServer({
+                devServerState,
+                viteDevServer: createMockViteDevServer(),
+            });
+            const ws = devServerState.extensionsWebSocket;
+            const callOrder = [];
+            const broadcastSpy = vi.spyOn(ws, 'broadcast').mockImplementation(() => {
+                callOrder.push('broadcast');
+            });
+            const closeSpy = vi.spyOn(ws, 'close').mockImplementation(async () => {
+                callOrder.push('close');
+            });
+            await shutdown();
+            expect(broadcastSpy).toHaveBeenCalledWith(expect.objectContaining({
+                event: 'shutdown',
+                version: 1,
+            }));
+            expect(closeSpy).toHaveBeenCalledOnce();
+            expect(callOrder).toEqual(['broadcast', 'close']);
+        });
         it('should trigger WebSocket setup after initialization', async () => {
             const triggerSpy = vi.spyOn(DevServerState.prototype, 'triggerWebSocketSetup');
             const devServerState = new DevServerState(devServerConfig);

package/dist/lib/app-functions/api/privateAppUserToken.d.ts

@@ -0,0 +1,16 @@
+import type { PrivateAppUserToken } from '../types.ts';
+import { HubSpotPromise } from '@hubspot/local-dev-lib/types/Http';
+interface TokenOptions {
+    userTokenKey: string;
+    scopeGroups?: string[];
+    expiresAt?: string;
+    privateAppToken?: string;
+}
+interface UserOptions {
+    accountId: number;
+    appId: number;
+}
+export declare function fetchPrivateAppUserToken({ accountId, appId, }: UserOptions): HubSpotPromise<PrivateAppUserToken>;
+export declare function createPrivateAppUserToken({ accountId, appId, scopeGroups, expiresAt, privateAppToken, }: UserOptions & Partial<TokenOptions>): HubSpotPromise<PrivateAppUserToken>;
+export declare function updatePrivateAppUserToken({ accountId, appId, userTokenKey, scopeGroups, expiresAt, privateAppToken, }: TokenOptions & UserOptions): HubSpotPromise<PrivateAppUserToken>;
+export {};

package/dist/lib/app-functions/api/privateAppUserToken.js

@@ -0,0 +1,28 @@
+import { http } from '@hubspot/local-dev-lib/http';
+const LOCALDEVAUTH_API_PRIVATE_APP_USER_TOKEN_PATH = 'localdevauth/v1/private-app/user-token';
+export async function fetchPrivateAppUserToken({ accountId, appId, }) {
+    return await http.get(accountId, {
+        url: `${LOCALDEVAUTH_API_PRIVATE_APP_USER_TOKEN_PATH}/${appId}`,
+    });
+}
+export async function createPrivateAppUserToken({ accountId, appId, scopeGroups, expiresAt, privateAppToken, }) {
+    return await http.post(accountId, {
+        url: `${LOCALDEVAUTH_API_PRIVATE_APP_USER_TOKEN_PATH}/${appId}`,
+        data: {
+            ...(scopeGroups && { scopeGroups }),
+            ...(expiresAt && { expiresAt }),
+            ...(privateAppToken && { privateAppToken }),
+        },
+    });
+}
+export async function updatePrivateAppUserToken({ accountId, appId, userTokenKey, scopeGroups, expiresAt, privateAppToken, }) {
+    return await http.put(accountId, {
+        url: `${LOCALDEVAUTH_API_PRIVATE_APP_USER_TOKEN_PATH}/${appId}`,
+        data: {
+            privateAppUserTokenKey: userTokenKey,
+            ...(scopeGroups && { scopeGroups }),
+            ...(expiresAt && { expiresAt }),
+            ...(privateAppToken && { privateAppToken }),
+        },
+    });
+}

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

@@ -0,0 +1,4 @@
+import { MultiFunctionInfo, ServiceConfiguration, SingleFunctionInfo } from './types.ts';
+export declare function loadMultiFunctionInfo(config: ServiceConfiguration): MultiFunctionInfo;
+export declare function loadFunctionInfo(config: ServiceConfiguration, functionName: string, appId?: number): SingleFunctionInfo;
+export declare function buildServiceConfiguration(appPath: string, options: Partial<ServiceConfiguration>): ServiceConfiguration;

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

@@ -0,0 +1,48 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { APP_FUNCTIONS_DIRNAME, APP_FUNCTIONS_MANIFEST_FILENAME, EXECUTION_TIMEOUT_MS, PLATFORM_VERSION, } from "./constants.js";
+import { Reason, ExecutionError } from "./errors.js";
+export function loadMultiFunctionInfo(config) {
+    const srcDir = path.join(config.app.path, APP_FUNCTIONS_DIRNAME);
+    if (!fs.existsSync(srcDir)) {
+        throw new Error(`Cannot locate app function directory: ${srcDir}`);
+    }
+    const stats = fs.lstatSync(srcDir);
+    if (!stats.isDirectory()) {
+        throw new Error(`Invalid app function directory: ${srcDir}`);
+    }
+    const manifestPath = path.join(srcDir, APP_FUNCTIONS_MANIFEST_FILENAME);
+    const manifest = JSON.parse(fs.readFileSync(manifestPath, {
+        encoding: 'utf-8',
+    }));
+    const { appFunctions = {} } = manifest;
+    // TODO validation
+    return { appFunctions, srcDir };
+}
+export function loadFunctionInfo(config, functionName, appId) {
+    const { logger } = config;
+    const { appFunctions, srcDir } = loadMultiFunctionInfo(config);
+    const metadata = appFunctions[functionName];
+    if (!metadata) {
+        const manifestPath = path.join(srcDir, APP_FUNCTIONS_MANIFEST_FILENAME);
+        logger.error(`App function "${functionName}" is not declared in ${manifestPath}`);
+        throw new ExecutionError({
+            reason: Reason.FunctionNotFound,
+            functionName,
+            appId,
+        });
+    }
+    // TODO validation
+    return { ...metadata, srcDir, name: functionName };
+}
+export function buildServiceConfiguration(appPath, options) {
+    return {
+        accountId: options.accountId,
+        app: { path: appPath },
+        functionTimeoutMs: options.functionTimeoutMs ?? EXECUTION_TIMEOUT_MS,
+        hubspotApiOrigin: options.hubspotApiOrigin,
+        hubspotWebsiteOrigin: options.hubspotWebsiteOrigin,
+        logger: options.logger ?? console,
+        platformVersion: options.platformVersion ?? PLATFORM_VERSION.V20231,
+    };
+}

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

@@ -0,0 +1,26 @@
+import { ProxyServerError } from './types.ts';
+export declare const APP_FUNCTIONS_DIRNAME = "app.functions";
+export declare const APP_FUNCTIONS_MANIFEST_FILENAME = "serverless.json";
+export declare const DEV_SERVER_DEFAULT_PORT = 6789;
+export declare const EXECUTION_TIMEOUT_MS = 15000;
+export declare const PRIVATE_APP_ACCESS_TOKEN = "PRIVATE_APP_ACCESS_TOKEN";
+export declare const SECRETS_IN_CONTEXT: string[];
+export declare const PLATFORM_VERSION: {
+    readonly V20231: "2023.1";
+    readonly V20232: "2023.2";
+    readonly V20251: "2025.1";
+    readonly V20252: "2025.2";
+    readonly UNSTABLE: "unstable";
+};
+export declare const defaultServerError: ProxyServerError;
+export declare const validationError: Omit<ProxyServerError, 'message' | 'data'>;
+export declare const axiosErrorMappings: {
+    [key: string]: ProxyServerError;
+};
+export declare const localProxyErrorMappings: {
+    BAD_GATEWAY: {
+        status: number;
+        category: string;
+        message: string;
+    };
+};