@hubspot/ui-extensions-dev-server 0.10.2 → 1.0.1

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

@@ -0,0 +1,737 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { isExtensionFileMock } from "../__mocks__/isExtensionFile.js";
+import { traverseAbstractSyntaxTree } from "../ast.js";
+import { generateHash } from "../utils.js";
+import { localParse } from "./test-utils/ast.js";
+vi.mock('../utils', async () => {
+    const originalModule = await vi.importActual('../utils');
+    return {
+        isExtensionFile: isExtensionFileMock,
+        generateHash: vi.fn().mockReturnValue('mock-hash-value'),
+        isImage: originalModule.isImage,
+    };
+});
+const invokedGlobalMatches = [
+    [`require('blah');`],
+    [`const foo = require('blah');`],
+    [`if (true) { require('blah');}`],
+    [`if (true) {} else { require('blah'); }`],
+    [`function bar() { require('blah') }`],
+    [`(function () {require('./module');})();`],
+    [
+        `if (false) {
+    function fdkasl() {
+      const blah = () => {
+        const blah2 = () => {
+          require('ok');
+        };
+      };
+    }
+  }`,
+    ],
+];
+const localMethodInvocations = [
+    [
+        `const require = a => {
+       console.log('this is valid', a);
+     };
+     require('');`,
+    ],
+    [
+        ` function require(a) {
+        console.log('this is valid', a);
+      }
+      require('');`,
+    ],
+    [
+        ` import { require } from 'blah';
+      require('');`,
+    ],
+    [
+        ` import require from 'blah';
+      require('');`,
+    ],
+    [
+        ` import * as require from 'blah';
+      require('');`,
+    ],
+    [
+        `function foo(require) {
+        require('blah')
+      }`,
+    ],
+    [
+        `const { require } = { require: () => {}};
+     require('')`,
+    ],
+];
+const ignoredInvocations = [[`foo.require()`]];
+describe('ast', () => {
+    const extensionPath = '/mock/extension/path';
+    const mockLogger = {
+        debug: vi.fn(),
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+    };
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('function checks', () => {
+        it('should not add metadata for a function that is not relevant in the source', () => {
+            const functionName = 'foo';
+            const program = localParse(`
+          const bar = () => {}
+      `);
+            const output = traverseAbstractSyntaxTree(program, [{ functionName }], extensionPath, mockLogger);
+            expect(output.functions[functionName]).toStrictEqual({});
+        });
+        it('should not add metadata for a function we are not checking for', () => {
+            const program = localParse(`
+          const bar = () => {}
+      `);
+            const output = traverseAbstractSyntaxTree(program, [], extensionPath, mockLogger);
+            expect(output.functions['bar']).toBe(undefined);
+        });
+        it.each(invokedGlobalMatches)('should flag invoked undefined methods as Global \n%s', (source) => {
+            const functionName = 'require';
+            const program = localParse(source);
+            const output = traverseAbstractSyntaxTree(program, [{ functionName }], extensionPath, mockLogger);
+            expect(output.functions[functionName]).toStrictEqual({
+                invoked: true,
+                scope: 'Global',
+            });
+        });
+        it.each(localMethodInvocations)('should flag defined invoked methods as Local \n%s', (source) => {
+            const functionName = 'require';
+            const program = localParse(source);
+            const output = traverseAbstractSyntaxTree(program, [{ functionName }], extensionPath, mockLogger);
+            expect(output.functions[functionName]).toStrictEqual({
+                invoked: true,
+                scope: 'Local',
+                defined: true,
+            });
+        });
+        it.each(ignoredInvocations)('should not gather metadata on irrelevant expressions \n%s', (source) => {
+            const functionName = 'require';
+            const program = localParse(source);
+            const output = traverseAbstractSyntaxTree(program, [{ functionName }], extensionPath, mockLogger);
+            expect(output.functions[functionName]).toStrictEqual({});
+        });
+        ['png', 'jpg', 'jpeg', 'gif', 'svg', 'webp', 'avif'].forEach((ext) => {
+            it(`Should correctly identify imports inside and outside the extension path for ${ext} type`, () => {
+                const program = localParse(`
+          import moduleA from './assets/local-image.${ext}';
+          import moduleB from '../assets/external-image.${ext}';
+        `);
+                const output = traverseAbstractSyntaxTree(program, [], extensionPath, mockLogger);
+                expect(output.badImports).toContain(`../assets/external-image.${ext}`);
+                expect(output.badImports).not.toContain(`./assets/local-image.${ext}`);
+            });
+        });
+        it('should not flag non-image imports', () => {
+            const program = localParse(`
+        import moduleA from '../utils/file.js';
+        import moduleB from './utils/file.js';
+        import moduleC from '@package/external-file.js';
+      `);
+            const output = traverseAbstractSyntaxTree(program, [], extensionPath, mockLogger);
+            expect(output.badImports).not.toContain('../utils/file.js');
+            expect(output.badImports).not.toContain('./utils/file.js');
+            expect(output.badImports).not.toContain('@package/external-file.js');
+        });
+        describe('data dependencies', () => {
+            it('should collect CRM properties from useCrmProperties hook', () => {
+                const source = `
+          import { useCrmProperties } from '@hubspot/ui-extensions/crm';
+          function MyComponent() {
+            const properties = useCrmProperties(['firstname', 'lastname']);
+          }
+        `;
+                const program = localParse(source);
+                const output = traverseAbstractSyntaxTree(program, [], extensionPath, mockLogger);
+                expect(output.dataDependencies.importedHooks).toHaveProperty('useCrmProperties', 'useCrmProperties');
+                expect(output.dataDependencies.dependencies).toHaveLength(1);
+                expect(output.dataDependencies.dependencies[0]).toEqual({
+                    referenceId: 'mock-hash-value',
+                    properties: {
+                        type: 'CrmRecordProperties',
+                        recordProperties: ['firstname', 'lastname'],
+                        options: {},
+                    },
+                });
+                expect(generateHash).toHaveBeenCalledWith('CrmRecordProperties', [
+                    'firstname',
+                    'lastname',
+                ]);
+            });
+            it('should handle useCrmProperties with no properties', () => {
+                const source = `
+          import { useCrmProperties } from '@hubspot/ui-extensions/crm';
+          function MyComponent() {
+            const properties = useCrmProperties([]);
+          }
+        `;
+                const program = localParse(source);
+                const output = traverseAbstractSyntaxTree(program, [], extensionPath, mockLogger);
+                expect(output.dataDependencies.importedHooks).toHaveProperty('useCrmProperties', 'useCrmProperties');
+                expect(output.dataDependencies.dependencies).toHaveLength(0);
+            });
+            it('should handle multiple useCrmProperties calls', () => {
+                const source = `
+          import { useCrmProperties } from '@hubspot/ui-extensions/crm';
+          function MyComponent() {
+            useCrmProperties(['firstname']);
+            useCrmProperties(['lastname']);
+          }
+        `;
+                const program = localParse(source);
+                const output = traverseAbstractSyntaxTree(program, [], extensionPath, mockLogger);
+                expect(output.dataDependencies.importedHooks).toHaveProperty('useCrmProperties', 'useCrmProperties');
+                expect(output.dataDependencies.dependencies).toHaveLength(2);
+                const dep0 = output.dataDependencies.dependencies[0];
+                const dep1 = output.dataDependencies.dependencies[1];
+                expect(dep0.properties.type).toBe('CrmRecordProperties');
+                expect(dep1.properties.type).toBe('CrmRecordProperties');
+                if (dep0.properties.type === 'CrmRecordProperties') {
+                    expect(dep0.properties.recordProperties).toEqual(['firstname']);
+                }
+                if (dep1.properties.type === 'CrmRecordProperties') {
+                    expect(dep1.properties.recordProperties).toEqual(['lastname']);
+                }
+            });
+            it('should handle non-string property names gracefully', () => {
+                const source = `
+          import { useCrmProperties } from '@hubspot/ui-extensions/crm';
+          function MyComponent() {
+            useCrmProperties(['firstname', 123, null]);
+          }
+        `;
+                const program = localParse(source);
+                const output = traverseAbstractSyntaxTree(program, [], extensionPath, mockLogger);
+                expect(output.dataDependencies.importedHooks).toHaveProperty('useCrmProperties', 'useCrmProperties');
+                expect(output.dataDependencies.dependencies).toHaveLength(1);
+                const dep = output.dataDependencies.dependencies[0];
+                expect(dep.properties.type).toBe('CrmRecordProperties');
+                if (dep.properties.type === 'CrmRecordProperties') {
+                    expect(dep.properties.recordProperties).toEqual(['firstname']);
+                }
+            });
+            it('should handle errors in data dependency collection', () => {
+                const source = `
+          import { useCrmProperties } from '@hubspot/ui-extensions/crm';
+          function MyComponent() {
+            useCrmProperties(['firstname']);
+          }
+        `;
+                const program = localParse(source);
+                // Mock generateHash to throw an error
+                vi.mocked(generateHash).mockImplementationOnce(() => {
+                    throw new Error('Hash generation failed');
+                });
+                const output = traverseAbstractSyntaxTree(program, [], extensionPath, mockLogger);
+                expect(output.dataDependencies.importedHooks).toHaveProperty('useCrmProperties', 'useCrmProperties');
+                expect(output.dataDependencies.dependencies).toEqual([]);
+                expect(mockLogger.warn).toHaveBeenCalledWith(expect.stringContaining('Error collecting data dependencies (skipping)'));
+            });
+            it('should handle malformed AST nodes gracefully', () => {
+                const source = `
+          import { useCrmProperties } from '@hubspot/ui-extensions/crm';
+          function MyComponent() {
+            useCrmProperties(); // Missing arguments
+          }
+        `;
+                const program = localParse(source);
+                const output = traverseAbstractSyntaxTree(program, [], extensionPath, mockLogger);
+                expect(output.dataDependencies.importedHooks).toHaveProperty('useCrmProperties', 'useCrmProperties');
+                expect(output.dataDependencies.dependencies).toEqual([]);
+            });
+            it('should not collect dependencies if hook is not imported', () => {
+                const source = `
+          function MyComponent() {
+            useCrmProperties(['firstname']);
+          }
+        `;
+                const program = localParse(source);
+                const output = traverseAbstractSyntaxTree(program, [], extensionPath, mockLogger);
+                expect(output.dataDependencies.importedHooks).not.toHaveProperty('useCrmProperties');
+                expect(output.dataDependencies.dependencies).toEqual([]);
+            });
+            it('should not collect dependencies if useCrmProperties is defined locally', () => {
+                const source = `
+          // Define a local function with the same name
+          function useCrmProperties(properties) {
+            return properties.map(p => ({ [p]: 'custom value' }));
+          }
+
+          function MyComponent() {
+            // This should not be treated as a HubSpot hook call
+            const result = useCrmProperties(['firstname', 'lastname']);
+          }
+        `;
+                const program = localParse(source);
+                const output = traverseAbstractSyntaxTree(program, [], extensionPath, mockLogger);
+                expect(output.dataDependencies.importedHooks).not.toHaveProperty('useCrmProperties');
+                expect(output.dataDependencies.dependencies).toEqual([]);
+            });
+            it('should handle namespace imports of useCrmProperties', () => {
+                const source = `
+          import * as hsCrm from '@hubspot/ui-extensions/crm';
+          function MyComponent() {
+            hsCrm.useCrmProperties(['firstname', 'lastname']);
+          }
+        `;
+                const program = localParse(source);
+                const output = traverseAbstractSyntaxTree(program, [], extensionPath, mockLogger);
+                expect(output.dataDependencies.importedHooks['hsCrm.useCrmProperties']).toBe('useCrmProperties');
+                expect(output.dataDependencies.dependencies).toHaveLength(1);
+                expect(output.dataDependencies.dependencies[0]).toEqual({
+                    referenceId: 'mock-hash-value',
+                    properties: {
+                        type: 'CrmRecordProperties',
+                        recordProperties: ['firstname', 'lastname'],
+                        options: {},
+                    },
+                });
+                expect(generateHash).toHaveBeenCalledWith('CrmRecordProperties', [
+                    'firstname',
+                    'lastname',
+                ]);
+            });
+            it('should handle aliased imports of useCrmProperties', () => {
+                const source = `
+          import { useCrmProperties as anotherHookName } from '@hubspot/ui-extensions/crm';
+          function MyComponent() {
+            anotherHookName(['firstname', 'lastname']);
+          }
+        `;
+                const program = localParse(source);
+                const output = traverseAbstractSyntaxTree(program, [], extensionPath, mockLogger);
+                expect(output.dataDependencies.importedHooks).toHaveProperty('anotherHookName', 'useCrmProperties');
+                expect(output.dataDependencies.dependencies).toHaveLength(1);
+                expect(output.dataDependencies.dependencies[0]).toEqual({
+                    referenceId: 'mock-hash-value',
+                    properties: {
+                        type: 'CrmRecordProperties',
+                        recordProperties: ['firstname', 'lastname'],
+                        options: {},
+                    },
+                });
+                expect(generateHash).toHaveBeenCalledWith('CrmRecordProperties', [
+                    'firstname',
+                    'lastname',
+                ]);
+            });
+            it('should handle useCrmProperties with formatting options', () => {
+                const source = `
+          import { useCrmProperties } from '@hubspot/ui-extensions/crm';
+          function MyComponent() {
+            const properties = useCrmProperties(
+              ['firstname', 'lastname', 'dealamount', 'telephone'],
+              { propertiesToFormat: ['dealamount', 'telephone'], formattingOptions: { currency: { addSymbol: true } } }
+            );
+          }
+        `;
+                const program = localParse(source);
+                const output = traverseAbstractSyntaxTree(program, [], extensionPath, mockLogger);
+                expect(output.dataDependencies.importedHooks).toHaveProperty('useCrmProperties', 'useCrmProperties');
+                expect(output.dataDependencies.dependencies).toHaveLength(1);
+                expect(output.dataDependencies.dependencies[0]).toEqual({
+                    referenceId: 'mock-hash-value',
+                    properties: {
+                        type: 'CrmRecordProperties',
+                        recordProperties: [
+                            'firstname',
+                            'lastname',
+                            'dealamount',
+                            'telephone',
+                        ],
+                        options: {
+                            propertiesToFormat: ['dealamount', 'telephone'],
+                            formattingOptions: {
+                                currency: { addSymbol: true },
+                            },
+                        },
+                    },
+                });
+                expect(generateHash).toHaveBeenCalledWith('CrmRecordProperties', [
+                    'firstname',
+                    'lastname',
+                    'dealamount',
+                    'telephone',
+                ]);
+            });
+            it('should resolve variables in useCrmProperties calls', () => {
+                const source = `
+          import { useCrmProperties } from '@hubspot/ui-extensions/crm';
+
+          const CONTACT_PROPERTIES = ['firstname', 'lastname', 'email'];
+          const DEAL_PROPERTIES = ['dealname', 'amount', 'stage'];
+          const contactOptions = { formatFields: ['email'] };
+          const dealOptions = { formatFields: ['amount'], currency: 'USD' };
+
+          function MyComponent() {
+            const { properties: contactProps } = useCrmProperties(CONTACT_PROPERTIES, { formatFields: 'all' });
+            const { properties: dealProps } = useCrmProperties(['closedate', 'probability'], dealOptions);
+            const { properties: mixedProps } = useCrmProperties(DEAL_PROPERTIES, contactOptions);
+          }
+        `;
+                const program = localParse(source);
+                const output = traverseAbstractSyntaxTree(program, [], extensionPath, mockLogger);
+                expect(output.dataDependencies.dependencies).toHaveLength(3);
+                expect(output.dataDependencies.dependencies[0]).toEqual({
+                    referenceId: 'mock-hash-value',
+                    properties: {
+                        type: 'CrmRecordProperties',
+                        recordProperties: ['firstname', 'lastname', 'email'],
+                        options: {
+                            formatFields: 'all',
+                        },
+                    },
+                });
+                expect(output.dataDependencies.dependencies[1]).toEqual({
+                    referenceId: 'mock-hash-value',
+                    properties: {
+                        type: 'CrmRecordProperties',
+                        recordProperties: ['closedate', 'probability'],
+                        options: {
+                            formatFields: ['amount'],
+                            currency: 'USD',
+                        },
+                    },
+                });
+                expect(output.dataDependencies.dependencies[2]).toEqual({
+                    referenceId: 'mock-hash-value',
+                    properties: {
+                        type: 'CrmRecordProperties',
+                        recordProperties: ['dealname', 'amount', 'stage'],
+                        options: {
+                            formatFields: ['email'],
+                        },
+                    },
+                });
+            });
+            it('should handle supported spread operators in useCrmProperties calls', () => {
+                const source = `
+          import { useCrmProperties } from '@hubspot/ui-extensions/crm';
+
+          const propsToFetch = ['firstname', 'lastname', 'email'];
+          const propsPartTwo = ['phone', 'company'];
+          const subOptions = {
+            date: {
+              relative: true,
+            }
+          }
+          // Unsupported spread operator
+          const propsFunction = () => ['createdate'];
+
+          const fieldsFormat = {
+            fieldsToFormat: ['firstname', 'lastname', 'email', 'phone'],
+          };
+
+          const options = {
+            ...fieldsFormat,
+            formattingOptions: {
+              date: {
+                relative: false,
+              },
+              ...{dateTime: { relative: true } },
+              ...subOptions
+            }
+          };
+
+
+          const { properties } = useCrmProperties([...propsToFetch, ...propsPartTwo], options);
+        `;
+                const program = localParse(source);
+                const output = traverseAbstractSyntaxTree(program, [], extensionPath, mockLogger);
+                expect(output.dataDependencies.dependencies).toHaveLength(1);
+                expect(output.dataDependencies.dependencies[0]).toEqual({
+                    referenceId: 'mock-hash-value',
+                    properties: {
+                        type: 'CrmRecordProperties',
+                        recordProperties: [
+                            'firstname',
+                            'lastname',
+                            'email',
+                            'phone',
+                            'company',
+                        ],
+                        options: {
+                            fieldsToFormat: ['firstname', 'lastname', 'email', 'phone'],
+                            formattingOptions: {
+                                date: {
+                                    relative: true,
+                                },
+                                dateTime: {
+                                    relative: true,
+                                },
+                            },
+                        },
+                    },
+                });
+            });
+            it('should not create data dependencies when unsupported spread operators are used', () => {
+                const source = `
+          import { useCrmProperties } from '@hubspot/ui-extensions/crm';
+
+          const propsToFetch = ['firstname', 'lastname'];
+          const propsFunction = () => ['email'];
+
+          const { properties } = useCrmProperties([...propsToFetch, ...propsFunction()]);
+        `;
+                const program = localParse(source);
+                const output = traverseAbstractSyntaxTree(program, [], extensionPath, mockLogger);
+                // Should not create any dependencies because parsing failed
+                expect(output.dataDependencies.dependencies).toHaveLength(0);
+            });
+            it('should handle template literals in useCrmProperties calls', () => {
+                const source = `
+          import { useCrmProperties } from '@hubspot/ui-extensions/crm';
+
+          const prefix = 'contact';
+          const suffix = 'name';
+          const config = { type: 'user', nested: { field: 'email' } };
+
+          function MyComponent() {
+            const { properties: test1 } = useCrmProperties([\`\${prefix}_\${suffix}\`]);
+            const { properties: test2 } = useCrmProperties([\`Hello \${prefix}\`]);
+            const { properties: test3 } = useCrmProperties([\`\${config.type}_id\`]);
+            const { properties: test4 } = useCrmProperties([\`\${config.nested.field}_formatted\`]);
+            const { properties: test5 } = useCrmProperties([\`static_prop\`, \`\${prefix}_dynamic\`]);
+          }
+        `;
+                const program = localParse(source);
+                const output = traverseAbstractSyntaxTree(program, [], extensionPath, mockLogger);
+                expect(output.dataDependencies.dependencies).toHaveLength(5);
+                output.dataDependencies.dependencies.forEach((dep) => {
+                    expect(dep.properties.type).toBe('CrmRecordProperties');
+                });
+                const deps = output.dataDependencies.dependencies;
+                if (deps[0].properties.type === 'CrmRecordProperties') {
+                    expect(deps[0].properties.recordProperties).toEqual(['contact_name']);
+                }
+                if (deps[1].properties.type === 'CrmRecordProperties') {
+                    expect(deps[1].properties.recordProperties).toEqual([
+                        'Hello contact',
+                    ]);
+                }
+                if (deps[2].properties.type === 'CrmRecordProperties') {
+                    expect(deps[2].properties.recordProperties).toEqual(['user_id']);
+                }
+                if (deps[3].properties.type === 'CrmRecordProperties') {
+                    expect(deps[3].properties.recordProperties).toEqual([
+                        'email_formatted',
+                    ]);
+                }
+                if (deps[4].properties.type === 'CrmRecordProperties') {
+                    expect(deps[4].properties.recordProperties).toEqual([
+                        'static_prop',
+                        'contact_dynamic',
+                    ]);
+                }
+            });
+        });
+    });
+    describe('variable collection', () => {
+        it('should collect all types of variable declarations', () => {
+            const source = `
+        const CONTACT_PROPERTIES = ['firstname', 'lastname', 'email'];
+        let USER_COUNT = 42;
+        var IS_ENABLED = true;
+        const CONFIG = { formatFields: ['email'] };
+      `;
+            const program = localParse(source);
+            const output = traverseAbstractSyntaxTree(program, [], extensionPath, mockLogger);
+            expect(output.variableDeclarations.get('CONTACT_PROPERTIES')).toEqual([
+                'firstname',
+                'lastname',
+                'email',
+            ]);
+            expect(output.variableDeclarations.get('USER_COUNT')).toBe(42);
+            expect(output.variableDeclarations.get('IS_ENABLED')).toBe(true);
+            expect(output.variableDeclarations.get('CONFIG')).toEqual({
+                formatFields: ['email'],
+            });
+        });
+        it('should track variable updates for let variables', () => {
+            const source = `
+        let PROPERTIES = ['firstname', 'lastname'];
+        PROPERTIES = ['firstname', 'lastname', 'email'];
+      `;
+            const program = localParse(source);
+            const output = traverseAbstractSyntaxTree(program, [], extensionPath, mockLogger);
+            // Should have the updated value, not the original
+            expect(output.variableDeclarations.get('PROPERTIES')).toEqual([
+                'firstname',
+                'lastname',
+                'email',
+            ]);
+        });
+        it('should handle multiple variable declarations in one statement', () => {
+            const source = `
+        const FIRST = ['a', 'b'], SECOND = { test: true }, THIRD = 'hello';
+      `;
+            const program = localParse(source);
+            const output = traverseAbstractSyntaxTree(program, [], extensionPath, mockLogger);
+            expect(output.variableDeclarations.get('FIRST')).toEqual(['a', 'b']);
+            expect(output.variableDeclarations.get('SECOND')).toEqual({ test: true });
+            expect(output.variableDeclarations.get('THIRD')).toBe('hello');
+        });
+    });
+    describe('useAssociations hook parsing', () => {
+        it('should parse basic useAssociations call', () => {
+            const source = `
+        import { useAssociations } from '@hubspot/ui-extensions/crm';
+        const result = useAssociations({
+          toObjectType: '0-1',
+          properties: ['firstname', 'lastname']
+        });
+      `;
+            const program = localParse(source);
+            const output = traverseAbstractSyntaxTree(program, [], extensionPath, mockLogger);
+            expect(output.dataDependencies.dependencies).toHaveLength(1);
+            const dep = output.dataDependencies.dependencies[0];
+            expect(dep.properties.type).toBe('CrmRecordAssociationProperties');
+            if (dep.properties.type === 'CrmRecordAssociationProperties') {
+                expect(dep.properties.toObjectTypeId).toBe('0-1');
+                expect(dep.properties.requestProperties).toEqual([
+                    'firstname',
+                    'lastname',
+                ]);
+                expect(dep.properties.paginationOptions).toEqual({});
+                expect(dep.properties.options).toEqual({});
+            }
+        });
+        it('should parse useAssociations with pagination options', () => {
+            const source = `
+        import { useAssociations } from '@hubspot/ui-extensions/crm';
+        const result = useAssociations({
+          toObjectType: '0-2',
+          properties: ['name', 'domain'],
+          pageLength: 25,
+          offset: 50
+        });
+      `;
+            const program = localParse(source);
+            const output = traverseAbstractSyntaxTree(program, [], extensionPath, mockLogger);
+            expect(output.dataDependencies.dependencies).toHaveLength(1);
+            const dep = output.dataDependencies.dependencies[0];
+            expect(dep.properties.type).toBe('CrmRecordAssociationProperties');
+            if (dep.properties.type === 'CrmRecordAssociationProperties') {
+                expect(dep.properties.toObjectTypeId).toBe('0-2');
+                expect(dep.properties.requestProperties).toEqual(['name', 'domain']);
+                expect(dep.properties.paginationOptions).toEqual({
+                    pageLength: 25,
+                    offset: 50,
+                });
+            }
+        });
+        it('should parse useAssociations with options', () => {
+            const source = `
+        import { useAssociations } from '@hubspot/ui-extensions/crm';
+        const result = useAssociations(
+          {
+            toObjectType: '0-3',
+            properties: ['dealname', 'amount']
+          },
+          {
+            propertiesToFormat: 'all',
+            formattingOptions: { currency: { addSymbol: true } }
+          }
+        );
+      `;
+            const program = localParse(source);
+            const output = traverseAbstractSyntaxTree(program, [], extensionPath, mockLogger);
+            expect(output.dataDependencies.dependencies).toHaveLength(1);
+            const dep = output.dataDependencies.dependencies[0];
+            expect(dep.properties.type).toBe('CrmRecordAssociationProperties');
+            if (dep.properties.type === 'CrmRecordAssociationProperties') {
+                expect(dep.properties.toObjectTypeId).toBe('0-3');
+                expect(dep.properties.requestProperties).toEqual([
+                    'dealname',
+                    'amount',
+                ]);
+                expect(dep.properties.options).toEqual({
+                    propertiesToFormat: 'all',
+                    formattingOptions: { currency: { addSymbol: true } },
+                });
+            }
+        });
+        it('should parse useAssociations with variable request', () => {
+            const source = `
+        import { useAssociations } from '@hubspot/ui-extensions/crm';
+        const request = {
+          toObjectType: '0-1',
+          properties: ['firstname', 'email'],
+          pageLength: 10
+        };
+        const result = useAssociations(request);
+      `;
+            const program = localParse(source);
+            const output = traverseAbstractSyntaxTree(program, [], extensionPath, mockLogger);
+            expect(output.dataDependencies.dependencies).toHaveLength(1);
+            const dep = output.dataDependencies.dependencies[0];
+            expect(dep.properties.type).toBe('CrmRecordAssociationProperties');
+            if (dep.properties.type === 'CrmRecordAssociationProperties') {
+                expect(dep.properties.toObjectTypeId).toBe('0-1');
+                expect(dep.properties.requestProperties).toEqual([
+                    'firstname',
+                    'email',
+                ]);
+                expect(dep.properties.paginationOptions).toEqual({ pageLength: 10 });
+            }
+        });
+        it('should handle namespace import for useAssociations', () => {
+            const source = `
+        import * as uiExtensions from '@hubspot/ui-extensions/crm';
+        const result = uiExtensions.useAssociations({
+          toObjectType: '0-2',
+          properties: ['name']
+        });
+      `;
+            const program = localParse(source);
+            const output = traverseAbstractSyntaxTree(program, [], extensionPath, mockLogger);
+            expect(output.dataDependencies.dependencies).toHaveLength(1);
+            const dep = output.dataDependencies.dependencies[0];
+            expect(dep.properties.type).toBe('CrmRecordAssociationProperties');
+            if (dep.properties.type === 'CrmRecordAssociationProperties') {
+                expect(dep.properties.toObjectTypeId).toBe('0-2');
+                expect(dep.properties.requestProperties).toEqual(['name']);
+            }
+        });
+        it('should handle aliased import for useAssociations', () => {
+            const source = `
+        import { useAssociations as useContactAssociations } from '@hubspot/ui-extensions/crm';
+        const result = useContactAssociations({
+          toObjectType: '0-1',
+          properties: ['firstname']
+        });
+      `;
+            const program = localParse(source);
+            const output = traverseAbstractSyntaxTree(program, [], extensionPath, mockLogger);
+            expect(output.dataDependencies.dependencies).toHaveLength(1);
+            const dep = output.dataDependencies.dependencies[0];
+            expect(dep.properties.type).toBe('CrmRecordAssociationProperties');
+            if (dep.properties.type === 'CrmRecordAssociationProperties') {
+                expect(dep.properties.toObjectTypeId).toBe('0-1');
+                expect(dep.properties.requestProperties).toEqual(['firstname']);
+            }
+        });
+        it('should generate correct reference ID for useAssociations', () => {
+            const source = `
+        import { useAssociations } from '@hubspot/ui-extensions/crm';
+        const result = useAssociations({
+          toObjectType: '0-1',
+          properties: ['lastname', 'firstname'] // Note: different order
+        });
+      `;
+            const program = localParse(source);
+            const output = traverseAbstractSyntaxTree(program, [], extensionPath, mockLogger);
+            expect(output.dataDependencies.dependencies).toHaveLength(1);
+            const dep = output.dataDependencies.dependencies[0];
+            const expectedReferenceId = generateHash('CrmRecordAssociationProperties', '0-1', 'firstname-lastname');
+            expect(dep.referenceId).toBe(expectedReferenceId);
+        });
+    });
+});