fix(fields): support ObjectStack 'reference' convention in LookupField

The ObjectStack backend uses `reference` (not `reference_to`) as the
property name for lookup field metadata. The entire codebase uses the
pattern `fieldDef.reference_to || fieldDef.reference` to handle both
conventions, but LookupField only checked `reference_to`.

This caused `referenceTo` to always be `undefined` when using the
ObjectStack backend, so `hasDataSource` was `false` and
`dataSource.find()` was never called — the dialog stayed empty.

Fixes:
- fieldMeta unwrapping now detects both `reference_to` and `reference`
  in the nested field object
- referenceTo falls back: `fieldMeta.reference_to || fieldMeta.reference`
- Added 2 new tests for the `reference` convention (nested + flat)

Co-authored-by: hotlong <50353452+hotlong@users.noreply.github.com>

Author: Copilot

packages/fields/src/complex-widgets.test.tsx

@@ -399,6 +399,89 @@ describe('Complex & Relationship Widgets', () => {
                 expect(screen.getByText('Order 002')).toBeInTheDocument();
             });
         });
+
+        it('supports ObjectStack "reference" convention (not just "reference_to")', async () => {
+            // ObjectStack backend uses `reference` instead of `reference_to`
+            const onChange = vi.fn();
+            mockDataSource.find.mockResolvedValue({
+                data: [
+                    { _id: 'a1', name: 'Acme Corp' },
+                    { _id: 'a2', name: 'Beta Inc' },
+                ],
+                total: 2,
+            });
+
+            const wrappedField = {
+                name: 'account',
+                label: 'Account',
+                field: {
+                    name: 'account',
+                    type: 'lookup',
+                    reference: 'account',  // ObjectStack convention
+                },
+                dataSource: mockDataSource,
+            } as any;
+
+            render(
+                <LookupField
+                    value={null}
+                    onChange={onChange}
+                    field={wrappedField}
+                    readonly={false}
+                />
+            );
+
+            await act(async () => {
+                fireEvent.click(screen.getByRole('button', { name: /Select/i }));
+            });
+
+            await waitFor(() => {
+                expect(mockDataSource.find).toHaveBeenCalledWith('account', { $top: 50 });
+            });
+
+            await waitFor(() => {
+                expect(screen.getByText('Acme Corp')).toBeInTheDocument();
+                expect(screen.getByText('Beta Inc')).toBeInTheDocument();
+            });
+        });
+
+        it('supports flat "reference" field without wrapper nesting', async () => {
+            // When field metadata is flat (no field.field nesting)
+            const onChange = vi.fn();
+            mockDataSource.find.mockResolvedValue({
+                data: [
+                    { _id: 'p1', name: 'Product A' },
+                ],
+                total: 1,
+            });
+
+            render(
+                <LookupField
+                    value={null}
+                    onChange={onChange}
+                    field={{
+                        name: 'product',
+                        label: 'Product',
+                        type: 'lookup',
+                        reference: 'products',  // ObjectStack convention, flat field
+                    } as any}
+                    readonly={false}
+                    dataSource={mockDataSource}
+                />
+            );
+
+            await act(async () => {
+                fireEvent.click(screen.getByRole('button', { name: /Select/i }));
+            });
+
+            await waitFor(() => {
+                expect(mockDataSource.find).toHaveBeenCalledWith('products', { $top: 50 });
+            });
+
+            await waitFor(() => {
+                expect(screen.getByText('Product A')).toBeInTheDocument();
+            });
+        });
     });
 
     describe('MasterDetailField', () => {

packages/fields/src/widgets/LookupField.tsx

@@ -84,8 +84,10 @@ export function LookupField({ value, onChange, field, readonly, ...props }: Fiel
   // When rendered via createFieldRenderer wrapper the actual objectSchema field
   // metadata (reference_to, display_field, etc.) lives at lookupField.field.
   // Unwrap it so lookup-specific properties resolve correctly.
+  // ObjectStack convention uses `reference` while the types use `reference_to`,
+  // so we check for both property names.
   const innerField = lookupField?.field;
-  const fieldMeta = (innerField && typeof innerField === 'object' && ('reference_to' in innerField || 'type' in innerField))
+  const fieldMeta = (innerField && typeof innerField === 'object' && ('reference_to' in innerField || 'reference' in innerField || 'type' in innerField))
     ? innerField
     : lookupField;
 
@@ -94,7 +96,8 @@ export function LookupField({ value, onChange, field, readonly, ...props }: Fiel
   const displayField = fieldMeta?.display_field || fieldMeta?.reference_field || 'name';
   const descriptionField: string | undefined = fieldMeta?.description_field;
   const idField = fieldMeta?.id_field || '_id';
-  const referenceTo: string | undefined = fieldMeta?.reference_to;
+  // ObjectStack convention uses `reference`; types define `reference_to` — support both
+  const referenceTo: string | undefined = fieldMeta?.reference_to || fieldMeta?.reference;
 
   // Resolve DataSource: explicit prop > field-level > wrapper field > SchemaRendererContext > none
   const ctx = useContext(SchemaRendererContext);