@hubspot/ui-extensions-dev-server 1.1.3 → 1.1.4

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

@@ -733,5 +733,26 @@ describe('ast', () => {
             const expectedReferenceId = generateHash('CrmRecordAssociationProperties', '0-1', 'firstname-lastname');
             expect(dep.referenceId).toBe(expectedReferenceId);
         });
+        it('should use default pageLength of 100 when offset is present but pageLength is missing', () => {
+            const source = `
+        import { useAssociations } from '@hubspot/ui-extensions/crm';
+        const result = useAssociations({
+          toObjectType: '0-1',
+          properties: ['firstname'],
+          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.paginationOptions).toEqual({
+                    pageLength: 100,
+                    offset: 50,
+                });
+            }
+        });
     });
 });

package/dist/lib/__tests__/plugins/friendlyLoggingPlugin.spec.js

@@ -1,5 +1,6 @@
 import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
 import friendlyLoggingPlugin from "../../plugins/friendlyLoggingPlugin.js";
+import path from 'path';
 describe('friendlyLoggingPlugin', () => {
     let plugin;
     let logger;
@@ -25,24 +26,24 @@ describe('friendlyLoggingPlugin', () => {
         });
     });
     describe('onLog', () => {
-        it('should return true if it is a log message we do not want altered', () => {
-            // @ts-expect-error TS doesn't think lifecycle hooks are functions
-            const result = plugin.onLog('error', {
-                code: "it's an older code but it checks out",
+        it('should not filter logs that are not mapped', () => {
+            const onLog = plugin.onLog;
+            const message = 'this is a test message';
+            const result = onLog('warn', {
+                code: 'some-unmapped-code',
+                message,
             });
-            expect(result).toBe(true);
-        });
-        it('should return false if it is a log message we want to transform', () => {
-            // @ts-expect-error TS doesn't think lifecycle hooks are functions
-            const result = plugin.onLog('error', {
-                code: 'MISSING_GLOBAL_NAME',
-            });
-            expect(result).toBe(false);
+            expect(result).toBe(true); // We always filter logs since we handle the logging
+            expect(logger.error).toHaveBeenCalledTimes(0);
+            expect(logger.info).toHaveBeenCalledTimes(0);
+            expect(logger.debug).toHaveBeenCalledTimes(0);
+            expect(logger.warn).toHaveBeenCalledTimes(0);
         });
-        it('should not log MISSING_GLOBAL_NAME errors', () => {
-            // @ts-expect-error TS doesn't think lifecycle hooks are functions
-            const result = plugin.onLog('error', {
+        it('should suppress MISSING_GLOBAL_NAME logs', () => {
+            const onLog = plugin.onLog;
+            const result = onLog('error', {
                 code: 'MISSING_GLOBAL_NAME',
+                message: 'this is a test message',
             });
             expect(result).toBe(false);
             expect(logger.error).toHaveBeenCalledTimes(0);
@@ -50,16 +51,31 @@ describe('friendlyLoggingPlugin', () => {
             expect(logger.debug).toHaveBeenCalledTimes(0);
             expect(logger.warn).toHaveBeenCalledTimes(0);
         });
-        it('should call the logger correctly for UNRESOLVED_IMPORT errors', () => {
-            // @ts-expect-error TS doesn't think lifecycle hooks are functions
-            const result = plugin.onLog('we ignore this for now', {
-                code: 'UNRESOLVED_IMPORT',
-                id: 'the/file/that/imported/the/bad/import.jsx',
-                exporter: '@hubspot/extensions',
+        it('should map UNRESOLVED_IMPORT logs to errors that throw', () => {
+            const onLog = plugin.onLog;
+            const importer = 'importer.jsx';
+            const exporter = 'missing-package';
+            const importerRelativePath = path.relative(process.cwd(), importer);
+            expect(() => {
+                onLog('warn', {
+                    code: 'UNRESOLVED_IMPORT',
+                    id: importer,
+                    exporter,
+                    message: 'this is a test message',
+                });
+            }).toThrow(`Build failed due to unresolved import. "${exporter}" is imported by "${importerRelativePath}", but "${exporter}" cannot be resolved. Make sure "${exporter}" is installed by adding it to your project's dependencies and running \`hs project install-deps\`.`);
+        });
+        it('should not filter unsupported log levels', () => {
+            const onLog = plugin.onLog;
+            const result = onLog('unsupported-log-level', {
+                code: 'some-unmapped-code',
+                message: 'this is a test message',
             });
-            expect(result).toBe(false);
-            expect(logger.error).toHaveBeenCalledTimes(1);
-            expect(logger.error).toHaveBeenCalledWith('@hubspot/extensions is imported by import.jsx, but @hubspot/extensions cannot be resolved. Make sure @hubspot/extensions is installed by running `hs project install-deps`.');
+            expect(result).toBe(true);
+            expect(logger.error).toHaveBeenCalledTimes(0);
+            expect(logger.info).toHaveBeenCalledTimes(0);
+            expect(logger.debug).toHaveBeenCalledTimes(0);
+            expect(logger.warn).toHaveBeenCalledTimes(0);
         });
     });
 });

package/dist/lib/ast.js

@@ -166,6 +166,13 @@ function _processAssociationsHook(node, output) {
     if (request.pageLength !== undefined) {
         paginationOptions.pageLength = request.pageLength;
     }
+    else if (request.offset !== undefined) {
+        /**
+         * If an offset is provided without a pageLength, we default to 100 (as we do at runtime)
+         * This avoids validation errors on the BE
+         */
+        paginationOptions.pageLength = 100;
+    }
     if (request.offset !== undefined) {
         paginationOptions.offset = request.offset;
     }

package/dist/lib/bin/cli.js

@@ -64,6 +64,7 @@ async function runCommand(command, options) {
         spinner.succeed(chalk.green(success));
     }
     catch (err) {
+        console.error('ERROR:', err);
         spinner.fail(chalk.red(error));
         process.exit(1);
     }

package/dist/lib/plugins/friendlyLoggingPlugin.js

@@ -1,10 +1,10 @@
 import path from 'path';
 const unfriendlyCodeMapper = Object.freeze({
-    UNRESOLVED_IMPORT: (loggable) => {
-        const { exporter, id } = loggable;
-        const { base: extension } = path.parse(id);
+    UNRESOLVED_IMPORT: (log) => {
+        const { exporter, id } = log;
+        const importerRelativePath = path.relative(process.cwd(), id);
         return {
-            message: `${exporter} is imported by ${extension}, but ${exporter} cannot be resolved. Make sure ${exporter} is installed by running \`hs project install-deps\`.`,
+            message: `Build failed due to unresolved import. "${exporter}" is imported by "${importerRelativePath}", but "${exporter}" cannot be resolved. Make sure "${exporter}" is installed by adding it to your project's dependencies and running \`hs project install-deps\`.`,
             level: 'error',
         };
     },
@@ -12,25 +12,33 @@ const unfriendlyCodeMapper = Object.freeze({
         return {};
     },
 });
-const unfriendlyCodeList = Object.freeze(Object.keys(unfriendlyCodeMapper));
 function friendlyLoggingPlugin({ logger }) {
     return {
         name: 'ui-extensions-friendly-logging-plugin',
         enforce: 'post',
-        onLog(_level, log) {
-            if (unfriendlyCodeList.includes(log.code || '')) {
-                const { message, level } = _mapMessageToFriendlyVersion(log);
-                if (message && level) {
-                    logger[level](message);
+        onLog(logLevel, log) {
+            const logMessage = log.message;
+            const logCode = log.code || '';
+            const mappedLog = logCode in unfriendlyCodeMapper
+                ? unfriendlyCodeMapper[logCode](log)
+                : null;
+            if (mappedLog) {
+                const targetLogLevel = mappedLog.level;
+                const targetLogMessage = mappedLog.message || logMessage;
+                if (!targetLogLevel) {
+                    // If the log is mapped, but doesn't have a level then suppress it
+                    return false;
                 }
-                return false; // Filter the log message
+                if (targetLogLevel === 'error') {
+                    // For errors, we want to throw the error so that the build fails
+                    throw new Error(targetLogMessage);
+                }
+                logger[targetLogLevel](targetLogMessage);
+                return false;
             }
-            return true; // We don't have a friendly log message, let it through
+            // We want to filter out the log so that it doesn't get logged again
+            return true;
         },
     };
 }
-function _mapMessageToFriendlyVersion(loggable) {
-    const { code } = loggable;
-    return unfriendlyCodeMapper[code]?.(loggable) ?? {};
-}
 export default friendlyLoggingPlugin;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hubspot/ui-extensions-dev-server",
-  "version": "1.1.3",
+  "version": "1.1.4",
   "description": "",
   "type": "module",
   "bin": {