Braze: Disable resource link fields [INTEG-2981]

apps/braze/src/fields/ExternalResourceField.ts

@@ -0,0 +1,44 @@
+import { Field } from './Field';
+import { FieldRegistry } from './fieldRegistry';
+
+export class ExternalResourceField extends Field {
+  constructor(id: string, name: string, entryContentTypeId: string, localized: boolean) {
+    super(id, name, entryContentTypeId, localized);
+  }
+
+  get type(): string {
+    return 'ExternalResourceField';
+  }
+
+  public override set selected(value: boolean) {
+    return;
+  }
+
+  static fromSerialized(serializedField: any): ExternalResourceField {
+    const field = new ExternalResourceField(
+      serializedField.id,
+      serializedField.name,
+      serializedField.entryContentTypeId,
+      serializedField.localized
+    );
+    return field;
+  }
+
+  generateQuery(): string {
+    throw new Error('External resource not supported');
+  }
+
+  generateLiquidTagForType(template: string): string[] {
+    throw new Error('External resource not supported');
+  }
+
+  isEnabledForGenerate(): boolean {
+    return false;
+  }
+
+  isEnabledForCreate(): boolean {
+    return false;
+  }
+}
+
+FieldRegistry.registerFieldType('ExternalResourceField', ExternalResourceField.fromSerialized);

apps/braze/src/fields/FieldsFactory.ts

@@ -15,6 +15,7 @@ import { ReferenceItem } from './ReferenceItem';
 import { RichTextField } from './RichTextField';
 import { TextArrayField } from './TextArrayField';
 import resolveResponse from 'contentful-resolve-response';
+import { ExternalResourceField } from './ExternalResourceField';
 
 export class FieldsFactory {
   private contentTypes: { [key: string]: ContentTypeProps };
@@ -134,6 +135,8 @@ export class FieldsFactory {
       fieldClass = RichTextField;
     } else if (fieldInfo.type === 'Location') {
       fieldClass = LocationField;
+    } else if (fieldInfo.type === 'ResourceLink') {
+      fieldClass = ExternalResourceField;
     } else {
       fieldClass = BasicField;
     }

apps/braze/src/fields/RichTextField.ts

@@ -22,7 +22,6 @@ export class RichTextField extends Field {
       serializedField.entryContentTypeId,
       serializedField.localized
     );
-    field.selected = serializedField.selected;
     return field;
   }
 
@@ -37,14 +36,6 @@ export class RichTextField extends Field {
   isEnabledForGenerate(): boolean {
     return false;
   }
-
-  displayNameForGenerate(): string {
-    return `${this.name} (Support for rich text fields coming soon)`;
-  }
-
-  displayNameForCreate(): string {
-    return this.name;
-  }
 }
 
 FieldRegistry.registerFieldType('RichTextField', RichTextField.fromSerialized);

apps/braze/test/fields/FieldsFactory.spec.ts

@@ -17,6 +17,7 @@ vi.mock('contentful-resolve-response', () => {
 
 // Import the mocked function for use in tests
 import resolveResponse from 'contentful-resolve-response';
+import { ExternalResourceField } from '../../src/fields/ExternalResourceField';
 
 describe('FieldsFactory', () => {
   const mockCma = {
@@ -475,6 +476,34 @@ describe('FieldsFactory', () => {
         'English Title'
       );
     });
+
+    it('should create an ExternalResourceField instance with correct properties', async () => {
+      const mockEntry = [
+        {
+          fields: {
+            externalReference: {
+              sys: { type: 'ResourceLink', linkType: 'Contentful:Entry', urn: 'an-id' },
+            },
+          },
+        },
+      ];
+      (resolveResponse as any).mockReturnValue(mockEntry);
+
+      mockCma.contentType.get.mockResolvedValue({
+        fields: [{ id: 'externalReference', type: 'ResourceLink', localized: false }],
+        sys: {
+          id: 'externalArticle',
+        },
+      });
+
+      const result = await createFields(entryId, entryContentTypeId, mockCma);
+      expect(result).toHaveLength(1);
+      expect(result[0]).toBeInstanceOf(ExternalResourceField);
+      const fieldInstance = result[0] as ExternalResourceField;
+      expect(fieldInstance.id).toBe('externalReference');
+      expect(fieldInstance.entryContentTypeId).toBe('externalArticle');
+      expect(fieldInstance.localized).toBe(false);
+    });
   });
 });