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

package/dist/lib/__tests__/app-functions/fixtures/v2023.2/app.functions/func-returns-implicitly.d.cts

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

package/dist/lib/__tests__/app-functions/fixtures/v2023.2/app.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__/app-functions/fixtures/v2023.2/app.functions/func-returns-promise-rejected.d.cts

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

package/dist/lib/__tests__/app-functions/fixtures/v2023.2/app.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__/app-functions/fixtures/v2023.2/app.functions/func-returns-promise-resolved.d.cts

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

package/dist/lib/__tests__/app-functions/fixtures/v2023.2/app.functions/func-returns-text.cjs

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

package/dist/lib/__tests__/app-functions/fixtures/v2023.2/app.functions/func-returns-text.d.cts

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

package/dist/lib/__tests__/app-functions/fixtures/v2023.2/app.functions/func-returns-undefined.cjs

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

package/dist/lib/__tests__/app-functions/fixtures/v2023.2/app.functions/func-returns-undefined.d.cts

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

package/dist/lib/__tests__/app-functions/fixtures/v2023.2/app.functions/func-throws-error.cjs

@@ -0,0 +1,4 @@
+"use strict";
+exports.main = () => {
+    throw new Error('Oops');
+};

package/dist/lib/__tests__/app-functions/fixtures/v2023.2/app.functions/func-throws-error.d.cts

@@ -0,0 +1 @@
+export function main(): never;

package/dist/lib/__tests__/app-functions/fixtures/v2023.2/app.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__/app-functions/fixtures/v2023.2/app.functions/func-times-out.d.cts

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

package/dist/lib/__tests__/app-functions/fixtures/v2023.2/app.functions/func-undeclared.cjs

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

package/dist/lib/__tests__/app-functions/fixtures/v2023.2/app.functions/func-undeclared.d.cts

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

package/dist/lib/__tests__/app-functions/fixtures/v2023.2/app.functions/func-uses-secret.cjs

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

package/dist/lib/__tests__/app-functions/fixtures/v2023.2/app.functions/func-uses-secret.d.cts

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

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

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

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

@@ -0,0 +1,278 @@
+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 { SAMPLE_FUNCTION_JS, SAMPLE_SERVERLESS_JSON, } from "./fixtures/constants.js";
+import { PrivateAppUserTokenManager } from "../../app-functions/services/PrivateAppUserTokenManager.js";
+const SRC_DIR = '/path/to/app.functions';
+const FUNCTION_NAME = 'sample-function';
+const FUNCTION_FILENAME = `${FUNCTION_NAME}.cjs`;
+function cloneSampleServerlessJson() {
+    return JSON.parse(JSON.stringify(SAMPLE_SERVERLESS_JSON));
+}
+function setFunctionSecrets(serverlessJson, functionName, secrets) {
+    if (serverlessJson.appFunctions[functionName] === undefined) {
+        throw new Error(`Function "${functionName}" is not declared in serverlessJson: ${JSON.stringify(serverlessJson)}`);
+    }
+    serverlessJson.appFunctions[functionName].secrets = [...secrets];
+}
+vi.mock('fs', async () => {
+    const memfs = await import('memfs');
+    return { default: memfs.fs, ...memfs.fs };
+});
+vi.mock('node:fs', async () => {
+    const memfs = await import('memfs');
+    return { default: memfs.fs, ...memfs.fs };
+});
+vi.mock('fs/promises', async () => {
+    const memfs = await import('memfs');
+    return { default: memfs.fs.promises, ...memfs.fs.promises };
+});
+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', () => ({
+    reportError: vi.fn(),
+}));
+/**
+ * Validate loading of secrets from .env files into process.env
+ */
+describe('loadSecrets', () => {
+    const initialEnvJson = JSON.stringify(process.env);
+    const serverlessJson = cloneSampleServerlessJson();
+    setFunctionSecrets(serverlessJson, FUNCTION_NAME, ['Token']);
+    afterEach(() => {
+        // restore process.env
+        process.env = JSON.parse(initialEnvJson);
+        vol.reset();
+        vi.resetAllMocks();
+    });
+    it('loads secrets from a .env file and puts them in process.env', () => {
+        vol.fromNestedJSON({
+            [SRC_DIR]: {
+                '.env': 'Token=tokentoken\nSomething=else',
+                [APP_FUNCTIONS_MANIFEST_FILENAME]: JSON.stringify(serverlessJson),
+                [FUNCTION_FILENAME]: SAMPLE_FUNCTION_JS,
+            },
+        });
+        const secrets = loadSecrets(SRC_DIR);
+        expect(process.env).toEqual({
+            ...JSON.parse(initialEnvJson),
+            Token: 'tokentoken',
+            Something: 'else',
+        });
+        expect(secrets).toEqual({});
+    });
+    it('loads secrets from a .env file, puts them in process.env and returns secrets for context', () => {
+        vol.fromNestedJSON({
+            [SRC_DIR]: {
+                '.env': 'Token=tokentoken\nSomething=else\nPRIVATE_APP_ACCESS_TOKEN=pat-na1-abababab',
+                [APP_FUNCTIONS_MANIFEST_FILENAME]: JSON.stringify(serverlessJson),
+                [FUNCTION_FILENAME]: SAMPLE_FUNCTION_JS,
+            },
+        });
+        const secrets = loadSecrets(SRC_DIR);
+        expect(process.env).toEqual({
+            ...JSON.parse(initialEnvJson),
+            Token: 'tokentoken',
+            Something: 'else',
+            PRIVATE_APP_ACCESS_TOKEN: 'pat-na1-abababab',
+        });
+        expect(secrets).toEqual({
+            PRIVATE_APP_ACCESS_TOKEN: 'pat-na1-abababab',
+        });
+    });
+    it('loads secrets cumulatively', () => {
+        vol.fromNestedJSON({
+            [SRC_DIR]: {
+                '.env': 'ALPHA=set-once\nBETA=set-once',
+                [APP_FUNCTIONS_MANIFEST_FILENAME]: JSON.stringify(serverlessJson),
+                [FUNCTION_FILENAME]: SAMPLE_FUNCTION_JS,
+            },
+        });
+        let secrets = loadSecrets(SRC_DIR);
+        expect(process.env).toEqual({
+            ...JSON.parse(initialEnvJson),
+            ALPHA: 'set-once',
+            BETA: 'set-once',
+        });
+        expect(secrets).toEqual({});
+        // Pretend the user has edited the file
+        vol.fromNestedJSON({
+            [SRC_DIR]: {
+                '.env': 'BETA=set-twice\nPRIVATE_APP_ACCESS_TOKEN=pat-na1-abababab',
+            },
+        });
+        secrets = loadSecrets(SRC_DIR);
+        expect(process.env).toEqual({
+            ...JSON.parse(initialEnvJson),
+            ALPHA: 'set-once', // ALPHA is still present because loadSecrets does not delete, only overrides
+            BETA: 'set-twice',
+            PRIVATE_APP_ACCESS_TOKEN: 'pat-na1-abababab',
+        });
+        expect(secrets).toEqual({
+            PRIVATE_APP_ACCESS_TOKEN: 'pat-na1-abababab',
+        });
+    });
+    it.skip('.env.[mode] > .env', () => {
+        vol.fromNestedJSON({
+            [SRC_DIR]: {
+                '.env': 'Level=1\nSomething=else',
+                '.env.test': 'Level=2',
+                [APP_FUNCTIONS_MANIFEST_FILENAME]: JSON.stringify(serverlessJson),
+                [FUNCTION_FILENAME]: SAMPLE_FUNCTION_JS,
+            },
+        });
+        const secrets = loadSecrets(SRC_DIR);
+        expect(process.env).toEqual({
+            ...JSON.parse(initialEnvJson),
+            Level: '2',
+        });
+        expect(secrets).toEqual({});
+    });
+    it(' .env.local > .env.[mode] > .env', () => {
+        vol.fromNestedJSON({
+            [SRC_DIR]: {
+                '.env': 'Level=1\nSomething=else',
+                '.env.test': 'Level=2',
+                '.env.local': 'Test=test\nLevel=3',
+                [APP_FUNCTIONS_MANIFEST_FILENAME]: JSON.stringify(serverlessJson),
+                [FUNCTION_FILENAME]: SAMPLE_FUNCTION_JS,
+            },
+        });
+        const secrets = loadSecrets(SRC_DIR);
+        expect(process.env).toEqual({
+            ...JSON.parse(initialEnvJson),
+            Test: 'test',
+            Level: '3',
+        });
+        expect(secrets).toEqual({});
+    });
+    it.skip('.env.[mode].local > .env.local > .env.[mode] > .env', () => {
+        vol.fromNestedJSON({
+            [SRC_DIR]: {
+                '.env': 'Level=1\nSomething=else',
+                '.env.test': 'Level=2',
+                '.env.local': 'Test=test\nLevel=3',
+                '.env.test.local': '',
+                [APP_FUNCTIONS_MANIFEST_FILENAME]: JSON.stringify(serverlessJson),
+                [FUNCTION_FILENAME]: SAMPLE_FUNCTION_JS,
+            },
+        });
+        const secrets = loadSecrets(SRC_DIR);
+        expect(process.env).toEqual({ ...JSON.parse(initialEnvJson) });
+        expect(secrets).toEqual({});
+    });
+    it('loads secrets as strings', () => {
+        vol.fromNestedJSON({
+            [SRC_DIR]: {
+                '.env': 'ZERO=0\nBOOL=false\nQUOTED="quoted string"\nSPACE=" "\nEMPTY=',
+                [APP_FUNCTIONS_MANIFEST_FILENAME]: JSON.stringify(serverlessJson),
+                [FUNCTION_FILENAME]: SAMPLE_FUNCTION_JS,
+            },
+        });
+        const secrets = loadSecrets(SRC_DIR);
+        expect(process.env).toEqual({
+            ...JSON.parse(initialEnvJson),
+            ZERO: '0',
+            BOOL: 'false',
+            QUOTED: 'quoted string',
+            SPACE: ' ',
+            EMPTY: '',
+        });
+        expect(secrets).toEqual({});
+    });
+    it('ignores if no .env file is found', () => {
+        vol.fromNestedJSON({
+            [SRC_DIR]: {
+                [APP_FUNCTIONS_MANIFEST_FILENAME]: JSON.stringify(serverlessJson),
+                [FUNCTION_FILENAME]: SAMPLE_FUNCTION_JS,
+            },
+        });
+        const secrets = loadSecrets(SRC_DIR);
+        expect(process.env).toEqual({ ...JSON.parse(initialEnvJson) });
+        expect(secrets).toEqual({});
+    });
+    it('ignores if the .env file is not valid', () => {
+        vol.fromNestedJSON({
+            [SRC_DIR]: {
+                '.env': 'gibberish',
+                [APP_FUNCTIONS_MANIFEST_FILENAME]: JSON.stringify(serverlessJson),
+                [FUNCTION_FILENAME]: SAMPLE_FUNCTION_JS,
+            },
+        });
+        const secrets = loadSecrets(SRC_DIR);
+        expect(process.env).toEqual({ ...JSON.parse(initialEnvJson) });
+        expect(secrets).toEqual({});
+    });
+});
+describe('setProperTokenInSecrets', () => {
+    let logger;
+    const initialEnvJson = JSON.stringify(process.env);
+    const privateAppUserToken = {
+        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',
+        },
+    };
+    beforeEach(() => {
+        logger = {
+            error: vi.fn(),
+            debug: vi.fn(),
+            info: vi.fn(),
+            warn: vi.fn(),
+        };
+    });
+    afterEach(() => {
+        // restore process.env
+        process.env = JSON.parse(initialEnvJson);
+        vi.resetAllMocks();
+    });
+    it('returns secrets unchanged if no privateAppUserToken is provided', () => {
+        const secrets = { [PRIVATE_APP_ACCESS_TOKEN]: 'pat-na1-557-4531' };
+        const result = setProperTokenInSecrets(secrets, logger);
+        expect(result).toEqual(secrets);
+    });
+    it('preserves the privateAppToken in PRIVATE_APP_ACCESS_TOKEN in secrets/env even if privateAppUserToken is provided', () => {
+        const appToken = 'pat-na1-557-4531';
+        process.env['PRIVATE_APP_ACCESS_TOKEN'] = appToken;
+        const secrets = { [PRIVATE_APP_ACCESS_TOKEN]: appToken };
+        const result = setProperTokenInSecrets(secrets, logger, privateAppUserToken);
+        expect(result).toEqual({
+            ...secrets,
+            PRIVATE_APP_ACCESS_TOKEN: appToken,
+        });
+        expect(process.env.PRIVATE_APP_ACCESS_TOKEN).toBe(appToken);
+    });
+    it('sets privateAppUserToken to PRIVATE_APP_ACCESS_TOKEN in secrets/env even no privateAppToken is provided', () => {
+        const secrets = {};
+        const result = setProperTokenInSecrets(secrets, logger, privateAppUserToken);
+        expect(result).toEqual({
+            ...secrets,
+            PRIVATE_APP_ACCESS_TOKEN: privateAppUserToken.userTokenKey,
+        });
+        expect(process.env.PRIVATE_APP_ACCESS_TOKEN).toBe(privateAppUserToken.userTokenKey);
+    });
+    it('logs a message if privateAppUserToken contains all scopes from privateAppToken', () => {
+        const secrets = { [PRIVATE_APP_ACCESS_TOKEN]: 'pat-na1-557-4531' };
+        setProperTokenInSecrets(secrets, logger, privateAppUserToken);
+        expect(logger.info).toHaveBeenCalledWith('The private app user token was overridden by the PRIVATE_APP_ACCESS_TOKEN in the environment file. For local development, you no longer need a PRIVATE_APP_ACCESS_TOKEN in the environment file. You can safely remove it.');
+    });
+    it('does not log a message if privateAppUserToken does not contain all scopes from privateAppToken', () => {
+        const secrets = { [PRIVATE_APP_ACCESS_TOKEN]: 'pat-na1-557-4531' };
+        vi.spyOn(PrivateAppUserTokenManager, 'doesUserTokenContainAppTokenScopes').mockReturnValue(false);
+        setProperTokenInSecrets(secrets, logger, privateAppUserToken);
+        expect(logger.info).not.toHaveBeenCalled();
+    });
+});

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

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