test(objectql): pin the unevaluable-rule log line per severity, at the evaluator and on an engine write

Co-authored-by: Claude <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01YJ2vytxktPaEAmkEavY9KP

Author: claude

.changeset/24782-advisory-unevaluable-log.md

@@ -0,0 +1,13 @@
+---
+'@objectstack/objectql': patch
+---
+
+fix(objectql): an advisory validation rule that cannot be evaluated logs one line saying the write proceeded, not two saying it was rejected (#24782)
+
+Clause-②: no (log text only: no response, status, code, outcome or export moves)
+
+A `severity: 'warning'` or `'info'` validation rule whose predicate cannot be evaluated never blocks the write. Only `error` rules fail closed (#4649). The write answers 2xx and the row persists. The server log said the opposite, twice. The predicate evaluator logged "— write rejected: a rule that cannot be evaluated fails closed, it is never skipped" before the rule's severity was consulted. Then the advisory per-write line repeated the unevaluable violation's own message, which also ends "— write rejected.".
+
+Such a rule now logs ONE line: `Validation rule 'NAME' (warning): the rule could not be evaluated (FAULT) — write proceeded: the rule is advisory, so it was not applied to this write`. This covers a `script` / `cross_field` condition, a `conditional`'s `when`, and the relationship-traversal refusal. On the seed / boot path the same text folds into that load's advisory summary line, which keeps its shape.
+
+Unchanged: an unevaluable `error` rule is refused with the same `400 VALIDATION_FAILED` body, and its log line still says the write was rejected and the rule fails closed. Which rules block is unchanged. An unevaluable rule still stays out of a write answer's `warnings`. `requiredWhen`, `readonlyWhen` and the option `visibleWhen` gate still refuse on every severity.

packages/objectql/src/validation/advisory-write-answer.test.ts

@@ -482,3 +482,33 @@ describe('[#22726] P2 — the preview appends the same hits to the row\'s `warni
     ]);
   });
 });
+
+describe('[#24782] an unevaluable advisory rule: the write succeeds, and the log says so once', () => {
+  beforeEach(async () => {
+    await boot();
+    engine.registry.registerObject({
+      name: 'adv_unevaluable',
+      label: 'Probe',
+      fields: { title: { name: 'title', label: 'Title', type: 'text' } },
+      validations: [{
+        type: 'script' as const,
+        name: 'qa_unevaluable_warn',
+        severity: 'warning' as const,
+        message: 'x',
+        condition: 'int(record.title) > 1',
+      }],
+    } as never, 'com.objectstack.test.24782');
+  });
+
+  it('createData stores the row, answers no `warnings`, and logs one advisory line', async () => {
+    const res: any = await protocol.createData({ object: 'adv_unevaluable', data: { title: 'abc' } });
+
+    expect(storeFor('adv_unevaluable').get(res.id)).toMatchObject({ title: 'abc' });
+    // #22726: an unevaluable rule has no verdict, so it is not a hit.
+    expect(Object.keys(res)).not.toContain('warnings');
+    const ruleLines = warns.filter((l) => l.includes('qa_unevaluable_warn'));
+    expect(ruleLines).toHaveLength(1);
+    expect(ruleLines[0]).toMatch(/^Validation rule 'qa_unevaluable_warn' \(warning\): the rule could not be evaluated \(.+\) — write proceeded/);
+    expect(ruleLines[0]).not.toMatch(/write rejected|fails closed/);
+  });
+});

packages/objectql/src/validation/rule-unevaluable-advisory-log.test.ts

@@ -172,7 +172,7 @@ describe('[#24782] CONTROL — an unevaluable `error` rule is refused, and its l
     expect(fields[0]!.message).toMatch(/^Validation rule 'qa_unevaluable' could not be evaluated \(.+\) — write rejected\./);
     expect(warns).toHaveLength(1);
     expect(warns[0]).toMatch(
-      /^Validation rule 'qa_unevaluable' predicate failed to evaluate \(.+\) — write rejected: a rule that cannot be evaluated fails closed, it is never skipped$/,
+      /^Validation rule 'qa_unevaluable' predicate failed to evaluate \(.+\) — write rejected: a rule that cannot be evaluated fails closed, it is never skipped$/s,
     );
   });
 
@@ -181,7 +181,7 @@ describe('[#24782] CONTROL — an unevaluable `error` rule is refused, and its l
 
     expect(refusalOf(thrown)[0]).toMatchObject({ constraint: { rule: 'qa_unevaluable_when', reason: 'unevaluable' } });
     expect(warns).toHaveLength(1);
-    expect(warns[0]).toMatch(/^Validation rule 'qa_unevaluable_when' when-predicate failed to evaluate \(.+\) — write rejected: a rule that cannot be evaluated fails closed/);
+    expect(warns[0]).toMatch(/^Validation rule 'qa_unevaluable_when' when-predicate failed to evaluate \(.+\) — write rejected: a rule that cannot be evaluated fails closed/s);
   });
 
   it('the relationship-traversal refusal', () => {