@object-ui/data-objectstack 16.1.0 → 17.1.0

package/src/userState.test.ts

@@ -144,7 +144,6 @@ describe('createObjectStackUserStateAdapter', () => {
         user_id: 'u1',
         key: 'ui.favorites',
         value: [{ id: 'a' }],
-        updated_at: expect.any(String),
       });
     });
 
@@ -165,11 +164,35 @@ describe('createObjectStackUserStateAdapter', () => {
 
       expect(ds.update).toHaveBeenCalledWith('sys_user_preference', 'row-99', {
         value: [{ id: 'x' }],
-        updated_at: expect.any(String),
       });
       expect(ds.create).not.toHaveBeenCalled();
     });
 
+    // #3794 — `updated_at` is server-managed. A caller-supplied value is
+    // stripped (framework #2948) and reported back as a dropped field, which
+    // the console turns into a "Some fields were not saved" toast. Stamping it
+    // here fired that warning on every recents/favorites write, about a field
+    // no user ever touched — noise on the exact surface that is supposed to
+    // tell a user their edit did not land.
+    it('never sends the server-managed updated_at column', async () => {
+      const ds = mockDataSource({
+        find: vi.fn().mockResolvedValue({ data: [] }) as any,
+        create: vi.fn().mockResolvedValue({ id: 'row-1' }) as any,
+      });
+      const adapter = createObjectStackUserStateAdapter({
+        dataSource: ds,
+        userId: 'u',
+        key: 'ui.recent',
+      });
+
+      await adapter.save([{ id: 'a' } as any]);
+      await adapter.save([{ id: 'b' } as any]);
+
+      for (const call of [...(ds.create as any).mock.calls, ...(ds.update as any).mock.calls]) {
+        expect(call[call.length - 1]).not.toHaveProperty('updated_at');
+      }
+    });
+
     it('uses the cached row id from a previous load on subsequent saves', async () => {
       const ds = mockDataSource({
         find: vi.fn().mockResolvedValue({
@@ -242,7 +265,6 @@ describe('createObjectStackUserStateAdapter', () => {
       expect(ds.create).toHaveBeenCalledTimes(1);
       expect(ds.update).toHaveBeenCalledWith('sys_user_preference', 'row-7', {
         value: [{ id: 'q' }],
-        updated_at: expect.any(String),
       });
     });
 
@@ -270,7 +292,6 @@ describe('createObjectStackUserStateAdapter', () => {
       expect(ds.create).toHaveBeenCalledTimes(1);
       expect(ds.update).toHaveBeenCalledWith('sys_user_preference', 'row-1', {
         value: [{ id: 'a' }, { id: 'b' }],
-        updated_at: expect.any(String),
       });
     });
 

package/src/userState.ts

@@ -159,13 +159,18 @@ export function createObjectStackUserStateAdapter<T = unknown>(
   // (a concurrent writer created the row, or the backend dropped our find
   // predicate), recover by re-finding and updating rather than surfacing the
   // failed insert.
+  //
+  // Deliberately does NOT stamp `updated_at`: the column is server-managed, and
+  // a non-system caller's write to it is stripped (framework #2948) and reported
+  // back as a dropped field — which the console surfaces as a "Some fields were
+  // not saved" toast (#3431). Sending it made every recents/favorites write pop
+  // a scary warning about a field the user never touched, drowning the real
+  // signal the toast exists for (#3794). The server stamps it either way.
   const upsert = async (items: T[]): Promise<void> => {
-    const now = new Date().toISOString();
-
     // Fast path: we already know the row id from a previous load/save.
     if (cachedRowId !== null) {
       try {
-        await dataSource.update(resource, cachedRowId, { value: items, updated_at: now });
+        await dataSource.update(resource, cachedRowId, { value: items });
         return;
       } catch (updateError) {
         // Row may have been deleted server-side — fall through to find/insert.
@@ -177,7 +182,7 @@ export function createObjectStackUserStateAdapter<T = unknown>(
     const existing = await findExisting();
     if (existing && existing.id !== undefined && existing.id !== null) {
       cachedRowId = existing.id;
-      await dataSource.update(resource, existing.id, { value: items, updated_at: now });
+      await dataSource.update(resource, existing.id, { value: items });
       return;
     }
 
@@ -186,7 +191,6 @@ export function createObjectStackUserStateAdapter<T = unknown>(
         user_id: userId,
         key,
         value: items,
-        updated_at: now,
       });
       const newId = (created as UserPreferenceRecord | undefined)?.id;
       if (newId !== undefined && newId !== null) cachedRowId = newId;
@@ -196,7 +200,7 @@ export function createObjectStackUserStateAdapter<T = unknown>(
       const recovered = await findExisting();
       if (recovered && recovered.id !== undefined && recovered.id !== null) {
         cachedRowId = recovered.id;
-        await dataSource.update(resource, recovered.id, { value: items, updated_at: now });
+        await dataSource.update(resource, recovered.id, { value: items });
         return;
       }
       throw createError;

package/src/validation-error.test.ts

@@ -0,0 +1,94 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import { describe, it, expect } from 'vitest';
+
+import { normaliseClientError } from './index';
+import { ValidationError } from './errors';
+
+/**
+ * The server has always sent per-field rejection detail; the adapter used to
+ * hand callers the raw client error, so `fields[]` had no typed home and every
+ * form fell back to one undirected toast.
+ */
+describe('normaliseClientError — VALIDATION_FAILED', () => {
+  // `@objectstack/rest` serves a thrown validation failure as 400 with `fields[]`
+  // verbatim; `@objectstack/client` sets `error.details` to the parsed body's
+  // `details` OR — as here, since the envelope has no such key — the whole body.
+  const upstream = () =>
+    Object.assign(new Error('Name is required; Stage is not a valid option'), {
+      code: 'VALIDATION_FAILED',
+      httpStatus: 400,
+      details: {
+        error: 'Name is required; Stage is not a valid option',
+        code: 'VALIDATION_FAILED',
+        fields: [
+          { field: 'name', code: 'required', message: 'Name is required' },
+          { field: 'stage', code: 'invalid_option', message: 'Stage is not a valid option' },
+        ],
+        object: 'crm_opportunity',
+      },
+    });
+
+  it('wraps it into a typed ValidationError', () => {
+    const normalised = normaliseClientError(upstream());
+    expect(normalised).toBeInstanceOf(ValidationError);
+  });
+
+  it('carries every field entry through', () => {
+    const normalised = normaliseClientError(upstream()) as ValidationError;
+    expect(normalised.validationErrors).toEqual([
+      { field: 'name', message: 'Name is required' },
+      { field: 'stage', message: 'Stage is not a valid option' },
+    ]);
+  });
+
+  it('keeps the server message verbatim — it names every field', () => {
+    const normalised = normaliseClientError(upstream()) as ValidationError;
+    expect(normalised.message).toBe('Name is required; Stage is not a valid option');
+  });
+
+  it('exposes the first offending field on `.field`', () => {
+    const normalised = normaliseClientError(upstream()) as ValidationError;
+    expect(normalised.field).toBe('name');
+  });
+
+  it('falls back to the machine code when an entry has no message', () => {
+    const err = Object.assign(new Error('Validation failed'), {
+      code: 'VALIDATION_FAILED',
+      details: { fields: [{ field: 'name', code: 'required' }] },
+    });
+    const normalised = normaliseClientError(err) as ValidationError;
+    expect(normalised.validationErrors).toEqual([{ field: 'name', message: 'required' }]);
+  });
+
+  it('drops entries with no field rather than inventing one', () => {
+    const err = Object.assign(new Error('Validation failed'), {
+      code: 'VALIDATION_FAILED',
+      details: { fields: [{ message: 'something is wrong' }] },
+    });
+    const normalised = normaliseClientError(err) as ValidationError;
+    expect(normalised.validationErrors).toEqual([]);
+  });
+
+  it('still wraps when the error carries `fields` directly (hand-rolled shape)', () => {
+    // The server duck-types on `code`/`name`, so a hook throwing the bare shape
+    // is served identically — the client must not be pickier than the server.
+    const err = Object.assign(new Error('nope'), {
+      name: 'ValidationError',
+      fields: [{ field: 'amount', message: 'Amount must be positive' }],
+    });
+    const normalised = normaliseClientError(err) as ValidationError;
+    expect(normalised.validationErrors).toEqual([{ field: 'amount', message: 'Amount must be positive' }]);
+  });
+
+  it('leaves an unrelated 400 untouched', () => {
+    const err = Object.assign(new Error('bad request'), { code: 'BAD_REQUEST', httpStatus: 400 });
+    expect(normaliseClientError(err)).toBe(err);
+  });
+});