Skip to content

The open alternative to Salesforce, designed for AI.

fix(front): pre-fill currency field default in record creation form (#27257)

Hussnain Ahmade2e385fca3d5
diff --git a/packages/twenty-front/src/modules/object-record/record-form/components/RecordFormFieldInputs.tsx b/packages/twenty-front/src/modules/object-record/record-form/components/RecordFormFieldInputs.tsx
index d8da696bd13..b57945a7c4e 100644
--- a/packages/twenty-front/src/modules/object-record/record-form/components/RecordFormFieldInputs.tsx
+++ b/packages/twenty-front/src/modules/object-record/record-form/components/RecordFormFieldInputs.tsx
@@ -3,6 +3,8 @@ import { type FieldMetadataItem } from '@/object-metadata/types/FieldMetadataIte
import { formatFieldMetadataItemAsFieldDefinition } from '@/object-metadata/utils/formatFieldMetadataItemAsFieldDefinition';
import { getFieldMetadataItemGqlFieldName } from '@/object-metadata/utils/getFieldMetadataItemGqlFieldName';
import { FormFieldInput } from '@/object-record/record-field/ui/components/FormFieldInput';
+import { RecordFormFieldInputsEffect } from '@/object-record/record-form/components/RecordFormFieldInputsEffect';
+import { getRecordFormCurrencyFieldDefaultValue } from '@/object-record/record-form/utils/getRecordFormCurrencyFieldDefaultValue';
import { getRecordFormFieldInputSettings } from '@/object-record/record-form/utils/getRecordFormFieldInputSettings';
import { type ObjectRecord } from '@/object-record/types/ObjectRecord';
import { type ValidationRuleViolation } from '@/validation-rules/types/ValidationRuleViolation';
@@ -36,34 +38,51 @@ export const RecordFormFieldInputs = ({
validationRuleViolationsByFieldMetadataId = {},
onFieldValueChange,
onFieldValueClear,
-}: RecordFormFieldInputsProps) => (
- <StyledFieldList>
- {fieldMetadataItems.map((fieldMetadataItem) => {
- const gqlFieldName = getFieldMetadataItemGqlFieldName(fieldMetadataItem);
+}: RecordFormFieldInputsProps) => {
+ return (
+ <>
+ <RecordFormFieldInputsEffect
+ fieldMetadataItems={fieldMetadataItems}
+ draftRecord={draftRecord}
+ onFieldValueChange={onFieldValueChange}
+ />
+ <StyledFieldList>
+ {fieldMetadataItems.map((fieldMetadataItem) => {
+ const gqlFieldName =
+ getFieldMetadataItemGqlFieldName(fieldMetadataItem);
- return (
- <Field.Root key={fieldMetadataItem.id}>
- <FormFieldInput
- field={formatFieldMetadataItemAsFieldDefinition({
- field: fieldMetadataItem,
- objectMetadataItem,
- showLabel: true,
- })}
- defaultValue={draftRecord[gqlFieldName]}
- onChange={(value) => onFieldValueChange(gqlFieldName, value)}
- onClear={() => onFieldValueClear(gqlFieldName)}
- settings={getRecordFormFieldInputSettings(fieldMetadataItem.type)}
- />
- {(
- validationRuleViolationsByFieldMetadataId[fieldMetadataItem.id] ??
- []
- ).map((violation) => (
- <Field.Error key={violation.ruleId} match role="alert">
- {violation.message}
- </Field.Error>
- ))}
- </Field.Root>
- );
- })}
- </StyledFieldList>
-);
+ return (
+ <Field.Root key={fieldMetadataItem.id}>
+ <FormFieldInput
+ field={formatFieldMetadataItemAsFieldDefinition({
+ field: fieldMetadataItem,
+ objectMetadataItem,
+ showLabel: true,
+ })}
+ defaultValue={
+ Object.hasOwn(draftRecord, gqlFieldName)
+ ? draftRecord[gqlFieldName]
+ : getRecordFormCurrencyFieldDefaultValue(fieldMetadataItem)
+ }
+ onChange={(value) => onFieldValueChange(gqlFieldName, value)}
+ onClear={() => onFieldValueClear(gqlFieldName)}
+ settings={getRecordFormFieldInputSettings(
+ fieldMetadataItem.type,
+ )}
+ />
+ {(
+ validationRuleViolationsByFieldMetadataId[
+ fieldMetadataItem.id
+ ] ?? []
+ ).map((violation) => (
+ <Field.Error key={violation.ruleId} match role="alert">
+ {violation.message}
+ </Field.Error>
+ ))}
+ </Field.Root>
+ );
+ })}
+ </StyledFieldList>
+ </>
+ );
+};
diff --git a/packages/twenty-front/src/modules/object-record/record-form/components/RecordFormFieldInputsEffect.tsx b/packages/twenty-front/src/modules/object-record/record-form/components/RecordFormFieldInputsEffect.tsx
new file mode 100644
index 00000000000..44e5aa427b4
--- /dev/null
+++ b/packages/twenty-front/src/modules/object-record/record-form/components/RecordFormFieldInputsEffect.tsx
@@ -0,0 +1,51 @@
+import { type FieldMetadataItem } from '@/object-metadata/types/FieldMetadataItem';
+import { getFieldMetadataItemGqlFieldName } from '@/object-metadata/utils/getFieldMetadataItemGqlFieldName';
+import { getRecordFormCurrencyFieldDefaultValue } from '@/object-record/record-form/utils/getRecordFormCurrencyFieldDefaultValue';
+import { type ObjectRecord } from '@/object-record/types/ObjectRecord';
+import { useEffect, useState } from 'react';
+import { type JsonValue } from 'type-fest';
+import { isDefined, isNonEmptyArray } from 'twenty-shared/utils';
+
+type RecordFormFieldInputsEffectProps = {
+ fieldMetadataItems: FieldMetadataItem[];
+ draftRecord: Partial<ObjectRecord>;
+ onFieldValueChange: (gqlFieldName: string, value: JsonValue) => void;
+};
+
+export const RecordFormFieldInputsEffect = ({
+ fieldMetadataItems,
+ draftRecord,
+ onFieldValueChange,
+}: RecordFormFieldInputsEffectProps) => {
+ const [hasSeededCurrencyDefaults, setHasSeededCurrencyDefaults] =
+ useState(false);
+
+ useEffect(() => {
+ if (hasSeededCurrencyDefaults || !isNonEmptyArray(fieldMetadataItems)) {
+ return;
+ }
+ setHasSeededCurrencyDefaults(true);
+
+ for (const fieldMetadataItem of fieldMetadataItems) {
+ const gqlFieldName = getFieldMetadataItemGqlFieldName(fieldMetadataItem);
+
+ if (Object.hasOwn(draftRecord, gqlFieldName)) {
+ continue;
+ }
+
+ const defaultValue =
+ getRecordFormCurrencyFieldDefaultValue(fieldMetadataItem);
+
+ if (isDefined(defaultValue)) {
+ onFieldValueChange(gqlFieldName, defaultValue);
+ }
+ }
+ }, [
+ draftRecord,
+ fieldMetadataItems,
+ hasSeededCurrencyDefaults,
+ onFieldValueChange,
+ ]);
+
+ return null;
+};
diff --git a/packages/twenty-front/src/modules/object-record/record-form/components/__tests__/RecordFormFieldInputs.clearing.test.tsx b/packages/twenty-front/src/modules/object-record/record-form/components/__tests__/RecordFormFieldInputs.clearing.test.tsx
new file mode 100644
index 00000000000..fb4513a592f
--- /dev/null
+++ b/packages/twenty-front/src/modules/object-record/record-form/components/__tests__/RecordFormFieldInputs.clearing.test.tsx
@@ -0,0 +1,151 @@
+import { type EnrichedObjectMetadataItem } from '@/object-metadata/types/EnrichedObjectMetadataItem';
+import { type FieldMetadataItem } from '@/object-metadata/types/FieldMetadataItem';
+import { RecordFormFieldInputs } from '@/object-record/record-form/components/RecordFormFieldInputs';
+import { type ObjectRecord } from '@/object-record/types/ObjectRecord';
+import { i18n } from '@lingui/core';
+import { I18nProvider } from '@lingui/react';
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { createStore, Provider } from 'jotai';
+import { useState } from 'react';
+import { CurrencyCode } from 'twenty-shared/constants';
+import { type JsonValue } from 'type-fest';
+import { FieldMetadataType } from '~/generated-metadata/graphql';
+
+jest.mock(
+ '@/object-record/record-field/ui/form-types/components/VariableChipStandalone',
+ () => ({
+ VariableChipStandalone: ({
+ rawVariableName,
+ }: {
+ rawVariableName: string;
+ }) => <span>{rawVariableName}</span>,
+ }),
+);
+
+// The rich text inputs pull in BlockNote, which jest cannot load; they are
+// never rendered for a currency field.
+jest.mock(
+ '@/object-record/record-field/ui/form-types/components/FormRecordRichTextFieldInput',
+ () => ({
+ FormRecordRichTextFieldInput: () => null,
+ }),
+);
+
+jest.mock(
+ '@/object-record/record-field/ui/form-types/components/FormRichTextFieldInput',
+ () => ({
+ FormRichTextFieldInput: () => null,
+ }),
+);
+
+const currencyFieldMetadataItem = {
+ id: 'amount-field-id',
+ name: 'amount',
+ label: 'Amount',
+ type: FieldMetadataType.CURRENCY,
+ defaultValue: { amountMicros: null, currencyCode: "'USD'" },
+} as unknown as FieldMetadataItem;
+
+const objectMetadataItem = {
+ id: 'opportunity-object-id',
+ nameSingular: 'opportunity',
+} as unknown as EnrichedObjectMetadataItem;
+
+const renderInputs = () => {
+ const onFieldValueChange = jest.fn();
+ const onFieldValueClear = jest.fn();
+ const store = createStore();
+
+ // Mirrors how the record creation form keeps the draft: a change writes the
+ // value under the field name, a clear writes null.
+ const Form = () => {
+ const [draftRecord, setDraftRecord] = useState<Partial<ObjectRecord>>({});
+
+ return (
+ <RecordFormFieldInputs
+ objectMetadataItem={objectMetadataItem}
+ fieldMetadataItems={[currencyFieldMetadataItem]}
+ draftRecord={draftRecord}
+ onFieldValueChange={(gqlFieldName: string, value: JsonValue) => {
+ onFieldValueChange(gqlFieldName, value);
+ setDraftRecord((previousDraftRecord) => ({
+ ...previousDraftRecord,
+ [gqlFieldName]: value,
+ }));
+ }}
+ onFieldValueClear={(gqlFieldName: string) => {
+ onFieldValueClear(gqlFieldName);
+ setDraftRecord((previousDraftRecord) => ({
+ ...previousDraftRecord,
+ [gqlFieldName]: null,
+ }));
+ }}
+ />
+ );
+ };
+
+ render(
+ <I18nProvider i18n={i18n}>
+ <Provider store={store}>
+ <Form />
+ </Provider>
+ </I18nProvider>,
+ );
+
+ return { onFieldValueChange, onFieldValueClear };
+};
+
+describe('RecordFormFieldInputs with the real currency input', () => {
+ it('pre-fills the metadata default currency', () => {
+ renderInputs();
+
+ expect(screen.getByText(/\(USD\)/)).toBeInTheDocument();
+ });
+
+ it('does not resurrect the default after the user clears the currency', async () => {
+ const user = userEvent.setup();
+ const { onFieldValueChange, onFieldValueClear } = renderInputs();
+
+ await user.click(screen.getByText(/\(USD\)/));
+ await user.click(await screen.findByText('No currency'));
+
+ // Clearing is a change carrying the emptied composite value, not a clear.
+ expect(onFieldValueChange).toHaveBeenCalledWith('amount', {
+ currencyCode: null,
+ amountMicros: null,
+ });
+ expect(onFieldValueClear).not.toHaveBeenCalled();
+
+ expect(screen.queryByText(/\(USD\)/)).not.toBeInTheDocument();
+ expect(screen.getByText('No currency')).toBeInTheDocument();
+ });
+
+ it('keeps the currency cleared when an amount is typed after clearing', async () => {
+ const user = userEvent.setup();
+ const { onFieldValueChange } = renderInputs();
+
+ await user.click(screen.getByText(/\(USD\)/));
+ await user.click(await screen.findByText('No currency'));
+ await user.type(screen.getByRole('textbox'), '25');
+
+ expect(onFieldValueChange).toHaveBeenLastCalledWith('amount', {
+ currencyCode: null,
+ amountMicros: 25_000_000,
+ });
+ expect(screen.queryByText(/\(USD\)/)).not.toBeInTheDocument();
+ });
+
+ it('keeps the default when an amount is typed without touching the currency', async () => {
+ const user = userEvent.setup();
+ const { onFieldValueChange } = renderInputs();
+
+ await user.type(screen.getByRole('textbox'), '3.21');
+
+ expect(onFieldValueChange).toHaveBeenLastCalledWith('amount', {
+ currencyCode: CurrencyCode.USD,
+ amountMicros: 3_210_000,
+ });
+ expect(screen.getByText(/\(USD\)/)).toBeInTheDocument();
+ });
+});
diff --git a/packages/twenty-front/src/modules/object-record/record-form/components/__tests__/RecordFormFieldInputs.test.tsx b/packages/twenty-front/src/modules/object-record/record-form/components/__tests__/RecordFormFieldInputs.test.tsx
new file mode 100644
index 00000000000..7779e4f59ab
--- /dev/null
+++ b/packages/twenty-front/src/modules/object-record/record-form/components/__tests__/RecordFormFieldInputs.test.tsx
@@ -0,0 +1,132 @@
+import { type EnrichedObjectMetadataItem } from '@/object-metadata/types/EnrichedObjectMetadataItem';
+import { type FieldMetadataItem } from '@/object-metadata/types/FieldMetadataItem';
+import { RecordFormFieldInputs } from '@/object-record/record-form/components/RecordFormFieldInputs';
+import { render } from '@testing-library/react';
+import { CurrencyCode } from 'twenty-shared/constants';
+import { FieldMetadataType } from '~/generated-metadata/graphql';
+
+const mockFormFieldInput = jest.fn((_: unknown) => null);
+
+jest.mock('@/object-record/record-field/ui/components/FormFieldInput', () => ({
+ FormFieldInput: (props: unknown) => mockFormFieldInput(props),
+}));
+
+const currencyFieldMetadataItem = {
+ id: 'amount-field-id',
+ name: 'amount',
+ label: 'Amount',
+ type: FieldMetadataType.CURRENCY,
+ defaultValue: { amountMicros: null, currencyCode: "'USD'" },
+} as unknown as FieldMetadataItem;
+
+const objectMetadataItem = {
+ id: 'opportunity-object-id',
+ nameSingular: 'opportunity',
+} as unknown as EnrichedObjectMetadataItem;
+
+const renderInputs = (
+ draftRecord: Record<string, unknown>,
+ onFieldValueChange = jest.fn(),
+) => {
+ render(
+ <RecordFormFieldInputs
+ objectMetadataItem={objectMetadataItem}
+ fieldMetadataItems={[currencyFieldMetadataItem]}
+ draftRecord={draftRecord}
+ onFieldValueChange={onFieldValueChange}
+ onFieldValueClear={jest.fn()}
+ />,
+ );
+
+ return onFieldValueChange;
+};
+
+const getPassedDefaultValue = () =>
+ (mockFormFieldInput.mock.calls.at(-1)?.[0] as { defaultValue: unknown })
+ .defaultValue;
+
+describe('RecordFormFieldInputs', () => {
+ beforeEach(() => {
+ mockFormFieldInput.mockClear();
+ });
+
+ it('pre-fills the currency field default when the draft has no value yet', () => {
+ renderInputs({});
+
+ expect(getPassedDefaultValue()).toEqual({
+ amountMicros: null,
+ currencyCode: CurrencyCode.USD,
+ });
+ });
+
+ it('keeps the draft value once the user has entered one', () => {
+ renderInputs({
+ amount: { amountMicros: 1500000000, currencyCode: CurrencyCode.EUR },
+ });
+
+ expect(getPassedDefaultValue()).toEqual({
+ amountMicros: 1500000000,
+ currencyCode: CurrencyCode.EUR,
+ });
+ });
+
+ it('does not resurrect the default after the field was cleared', () => {
+ renderInputs({ amount: null });
+
+ expect(getPassedDefaultValue()).toBeNull();
+ });
+
+ it('seeds the draft with the currency default on mount when the draft has no value yet', () => {
+ const onFieldValueChange = renderInputs({});
+
+ expect(onFieldValueChange).toHaveBeenCalledWith('amount', {
+ amountMicros: null,
+ currencyCode: CurrencyCode.USD,
+ });
+ });
+
+ it('seeds the draft once the field list arrives after an empty first render', () => {
+ const onFieldValueChange = jest.fn();
+
+ const { rerender } = render(
+ <RecordFormFieldInputs
+ objectMetadataItem={objectMetadataItem}
+ fieldMetadataItems={[]}
+ draftRecord={{}}
+ onFieldValueChange={onFieldValueChange}
+ onFieldValueClear={jest.fn()}
+ />,
+ );
+
+ expect(onFieldValueChange).not.toHaveBeenCalled();
+
+ rerender(
+ <RecordFormFieldInputs
+ objectMetadataItem={objectMetadataItem}
+ fieldMetadataItems={[currencyFieldMetadataItem]}
+ draftRecord={{}}
+ onFieldValueChange={onFieldValueChange}
+ onFieldValueClear={jest.fn()}
+ />,
+ );
+
+ expect(onFieldValueChange).toHaveBeenCalledWith('amount', {
+ amountMicros: null,
+ currencyCode: CurrencyCode.USD,
+ });
+ });
+
+ it('does not seed the draft when it already has a value', () => {
+ const onFieldValueChange = renderInputs({
+ amount: { amountMicros: 1500000000, currencyCode: CurrencyCode.EUR },
+ });
+
+ expect(onFieldValueChange).not.toHaveBeenCalled();
+ });
+
+ it('does not seed the draft again after the field was cleared', () => {
+ const onFieldValueChange = renderInputs({ amount: null });
+
+ expect(onFieldValueChange).not.toHaveBeenCalled();
+ });
+});
diff --git a/packages/twenty-front/src/modules/object-record/record-form/utils/__tests__/getRecordFormCurrencyFieldDefaultValue.test.ts b/packages/twenty-front/src/modules/object-record/record-form/utils/__tests__/getRecordFormCurrencyFieldDefaultValue.test.ts
new file mode 100644
index 00000000000..ae01f3fb640
--- /dev/null
+++ b/packages/twenty-front/src/modules/object-record/record-form/utils/__tests__/getRecordFormCurrencyFieldDefaultValue.test.ts
@@ -0,0 +1,50 @@
+import { getRecordFormCurrencyFieldDefaultValue } from '@/object-record/record-form/utils/getRecordFormCurrencyFieldDefaultValue';
+import { CurrencyCode } from 'twenty-shared/constants';
+import { FieldMetadataType } from '~/generated-metadata/graphql';
+
+describe('getRecordFormCurrencyFieldDefaultValue', () => {
+ it('returns the normalized default for a currency field', () => {
+ expect(
+ getRecordFormCurrencyFieldDefaultValue({
+ type: FieldMetadataType.CURRENCY,
+ defaultValue: { amountMicros: null, currencyCode: "'USD'" },
+ }),
+ ).toEqual({ amountMicros: null, currencyCode: CurrencyCode.USD });
+ });
+
+ it('keeps a default amount when one is set', () => {
+ expect(
+ getRecordFormCurrencyFieldDefaultValue({
+ type: FieldMetadataType.CURRENCY,
+ defaultValue: { amountMicros: 5000000, currencyCode: "'EUR'" },
+ }),
+ ).toEqual({ amountMicros: 5000000, currencyCode: CurrencyCode.EUR });
+ });
+
+ it('returns undefined when the field has no default value', () => {
+ expect(
+ getRecordFormCurrencyFieldDefaultValue({
+ type: FieldMetadataType.CURRENCY,
+ defaultValue: undefined,
+ }),
+ ).toBeUndefined();
+ });
+
+ it('returns undefined when the default value is not a valid currency default', () => {
+ expect(
+ getRecordFormCurrencyFieldDefaultValue({
+ type: FieldMetadataType.CURRENCY,
+ defaultValue: { amountMicros: null, currencyCode: "'NOT_A_CODE'" },
+ }),
+ ).toBeUndefined();
+ });
+
+ it('returns undefined for non-currency fields', () => {
+ expect(
+ getRecordFormCurrencyFieldDefaultValue({
+ type: FieldMetadataType.TEXT,
+ defaultValue: { amountMicros: null, currencyCode: "'USD'" },
+ }),
+ ).toBeUndefined();
+ });
+});
diff --git a/packages/twenty-front/src/modules/object-record/record-form/utils/getRecordFormCurrencyFieldDefaultValue.ts b/packages/twenty-front/src/modules/object-record/record-form/utils/getRecordFormCurrencyFieldDefaultValue.ts
new file mode 100644
index 00000000000..2a536d01443
--- /dev/null
+++ b/packages/twenty-front/src/modules/object-record/record-form/utils/getRecordFormCurrencyFieldDefaultValue.ts
@@ -0,0 +1,34 @@
+import { type FieldMetadataItem } from '@/object-metadata/types/FieldMetadataItem';
+import { type FieldCurrencyValue } from '@/object-record/record-field/ui/types/FieldMetadata';
+import { currencyFieldDefaultValueSchema } from '@/object-record/record-field/ui/validation-schemas/currencyFieldDefaultValueSchema';
+import { isDefined } from 'twenty-shared/utils';
+import { FieldMetadataType } from '~/generated-metadata/graphql';
+import { stripSimpleQuotesFromString } from '~/utils/string/stripSimpleQuotesFromString';
+import { type CurrencyCode } from 'twenty-shared/constants';
+
+export const getRecordFormCurrencyFieldDefaultValue = (
+ fieldMetadataItem: Pick<FieldMetadataItem, 'type' | 'defaultValue'>,
+): FieldCurrencyValue | undefined => {
+ if (fieldMetadataItem.type !== FieldMetadataType.CURRENCY) {
+ return undefined;
+ }
+
+ if (!isDefined(fieldMetadataItem.defaultValue)) {
+ return undefined;
+ }
+
+ const parsedDefaultValue = currencyFieldDefaultValueSchema.safeParse(
+ fieldMetadataItem.defaultValue,
+ );
+
+ if (!parsedDefaultValue.success) {
+ return undefined;
+ }
+
+ return {
+ amountMicros: parsedDefaultValue.data.amountMicros,
+ currencyCode: stripSimpleQuotesFromString(
+ parsedDefaultValue.data.currencyCode,
+ ) as CurrencyCode,
+ };
+};