@qoretechnologies/reqraft 0.10.39 → 0.10.40-pr.100.g0cc0f4b

package/src/components/form/engine/CompactRow.tsx

@@ -23,7 +23,7 @@ import isEqual from 'lodash/isEqual';
 import size from 'lodash/size';
 import React, { memo } from 'react';
 import { useContextSelector } from 'use-context-selector';
-import { hasAllDependenciesFullfilled } from '../../../helpers/validations';
+import { hasAllDependenciesFullfilled, parseDependency } from '../../../helpers/validations';
 import {
   findTemplate,
   getTemplateTagStyle,
@@ -1622,35 +1622,45 @@ export const CompactRow = memo(
       showFieldTypes ?
         `<${(schema?.ui_type as string) || (schema?.type as string) || 'auto'}${(schema as { ui_element_type?: string } | undefined)?.ui_element_type ? `[${(schema as { ui_element_type?: string }).ui_element_type}]` : ''}>`
       : null;
-    // Disabled rows (schema flag or unmet deps) can't open — a lock + reason
-    // renders instead. Form-level readOnly still opens in view mode (Close).
+    // A `readonly` field is one the system owns — an assigned id, a recorded
+    // provenance. The server states that on the field itself; only the older
+    // compat projection also mapped it to `disabled`, so on this path the form
+    // was handed `readonly` alone and rendered an editable control for a value
+    // no answer of the user's can change.
+    const fieldReadonly = !!(schema as { readonly?: boolean } | undefined)?.readonly;
+    // Disabled rows (schema flag, readonly, or unmet deps) can't open — a lock +
+    // reason renders instead. Form-level readOnly still opens in view mode (Close).
     const fieldDisabled =
       !hidden &&
       !readOnly &&
       (!!schema?.disabled ||
+        fieldReadonly ||
         !hasAllDependenciesFullfilled(schema?.depends_on, availableOptions, options || {}));
     const fieldDisabledReason =
-      schema?.disabled ? 'This field is disabled' : 'Disabled — dependencies are not fulfilled';
+      schema?.disabled ? 'This field is disabled'
+      : fieldReadonly ? 'Set by Qorus — not editable'
+      : 'Disabled — dependencies are not fulfilled';
     // Dependency contract: top-level entries must ALL hold; a nested array
-    // means ANY of its entries; `name=value` requires that exact value.
+    // means ANY of its entries; `name=value` requires that exact value, and
+    // `name!=value` requires any other answer. Parsed by the same helper the
+    // predicate uses, so the lock cannot describe a rule the form does not apply.
     const dependencyEntries =
-      fieldDisabled && !schema?.disabled ?
+      fieldDisabled && !schema?.disabled && !fieldReadonly ?
         ((schema?.depends_on || []) as (string | string[])[])
       : [];
     const describeDependency = (dep: string) => {
-      const eqIndex = dep.indexOf('=');
-      const depName = eqIndex === -1 ? dep : dep.slice(0, eqIndex);
-      const expected = eqIndex === -1 ? undefined : dep.slice(eqIndex + 1);
+      const { name: depName, op, value: expected } = parseDependency(dep);
       const depLabel = (options?.[depName]?.display_name as string) || depName;
       const depValue = (availableOptions as TQorusForm)?.[depName]?.value;
       return {
         name: depName,
         exists: !!options?.[depName],
-        label: expected === undefined ? depLabel : `${depLabel} = ${expected}`,
+        label: !op ? depLabel : `${depLabel} ${op === '=' ? '=' : '≠'} ${expected}`,
         fulfilled:
-          expected === undefined ?
-            !isOptionValueEmpty(depValue)
-          : depValue != null && String(depValue) === expected,
+          !op ? !isOptionValueEmpty(depValue)
+          : depValue == null ? false
+          : op === '=' ? String(depValue) === expected
+          : String(depValue) !== expected,
       };
     };
     const depHighlightNames = (flatten(dependencyEntries as never[]) as string[])
@@ -1869,8 +1879,20 @@ export const CompactRow = memo(
               reads less like a summary than like a second, disagreeing answer.
               An UNDESCRIBED value keeps its summary: the data tree beneath it
               says nothing about what the value MEANS, so the summary is still
-              the only line that does. */}
-          {showMarkdownPreview || previewWithSchema ? null : (
+              the only line that does.
+
+              Both suppressions are conditional on the replacement ACTUALLY
+              rendering. `previewWithSchema` only asks whether the value and its
+              `arg_schema` COULD be drawn as a schema preview; whether one is
+              drawn is `showStructuredPreview`, and the two disagree for a field
+              whose value type is a host ui_type rather than a list or a hash —
+              a test's `cases` (`ui_type: "test-cases"`, an array of case hashes
+              with an `arg_schema`) could be previewed but is not, because
+              `isHashList` only recognises `list`/`free-list`/`array`. The row
+              then dropped its summary in favour of a preview that never came
+              and rendered nothing at all: a test with cases read as a bare
+              "Cases" and looked unset until it was opened. */}
+          {showMarkdownPreview || (previewWithSchema && showStructuredPreview) ? null : (
             <span className='options-readfirst-valuetext'>
               {hidden || empty ? '—' : renderReadFirstValue(optionField, schema, formatted)}
             </span>

package/src/components/form/engine/FormEngine.tsx

@@ -2340,6 +2340,11 @@ const FormEngineImpl = ({
             allowed_values_creatable={options?.[optionName]?.allowed_values_creatable}
             disabled={
               options?.[optionName]?.disabled ||
+              // a system-owned field states that as `readonly`; only the older
+              // compat projection also sent `disabled`, so honouring only
+              // `disabled` rendered an editable control for a value the user
+              // cannot change (see CompactRow's `fieldReadonly`)
+              (options?.[optionName] as { readonly?: boolean } | undefined)?.readonly ||
               readOnly ||
               !hasAllDependenciesFullfilled(
                 options?.[optionName]?.depends_on,

package/src/components/form/engine/readFirst.ts

@@ -676,12 +676,27 @@ export const getHashEntries = (
     // whose entries are `{ type: 'string', value: 'x' }`) — recognise those by
     // their strict shape (a string `type`, a `value`, and no foreign keys) so
     // the sub-row shows 'x' rather than counting the envelope's own keys.
+    // `'value' in raw` is FALSE for a materialised-but-unset field: `fixOptions`
+    // omits the key entirely when the value is undefined, leaving `{type: 'x'}`.
+    // Requiring `value` therefore classed that envelope as a raw hash VALUE and
+    // counted its own `type` key, so an untouched Runtime Defaults collapsed to
+    // "Timeout (Seconds) 1 field" three times over while the sub-form correctly
+    // said 0/3 set. With a sub-schema present, a `type`-only object is an empty
+    // envelope, never content.
+    const isEmptyEnvelope =
+      !!subSchema &&
+      !!raw &&
+      typeof raw === 'object' &&
+      !Array.isArray(raw) &&
+      !('value' in (raw as object)) &&
+      Object.keys(raw as object).every((k) => k === 'type' || k === 'is_expression');
     const isFieldShape =
       (!!subSchema &&
         !!raw &&
         typeof raw === 'object' &&
         !Array.isArray(raw) &&
         'value' in (raw as object)) ||
+      isEmptyEnvelope ||
       isTypedEnvelope(raw);
     const subOption: IQorusFormField =
       isFieldShape ?

package/src/components/form/fields/auto/AutoFormField.tsx

@@ -364,6 +364,18 @@ function AutoField<T = any>({
     return (
       <Override
         {...rest}
+        // The field's SHAPE, which `rest` does not carry: these three are
+        // destructured into named props above, so a host editor received a
+        // field it could not describe. `arg_schema` is the sub-schema a host
+        // sub-form renders FROM — without it the IDE's test-cases drawer fell
+        // back to humanising each key, so `Path`, `Actual` and `Expected` were
+        // asked for with no label of their own and no description, while the
+        // text sat one fetch away. `element_type`/`ui_element_type` travel with
+        // it: a sub-schema alone cannot say whether the value is one hash or a
+        // list of them.
+        arg_schema={arg_schema}
+        element_type={element_type}
+        ui_element_type={ui_element_type}
         name={name}
         value={value}
         onChange={(val: any, emittedType?: IQorusType, emittedIsFunction?: boolean) => {

package/src/helpers/validations.ts

@@ -1809,6 +1809,68 @@ export const getUnresolvedRequiredOptions = (
   return unresolved;
 };
 
+/**
+ * Split a dependency entry into the sibling it names and how its value is compared.
+ *
+ * Three forms: `name` (the sibling must simply have a value), `name=value` (it must
+ * have exactly that value) and `name!=value` (it must have a value, and not that
+ * one). The negative form is what lets a field say it applies to every variant of a
+ * record but one — spelling that as an `any-of` list of every other variant is both
+ * unreadable in the "Depends on" lock and silently wrong the moment a variant is
+ * added.
+ *
+ * `!=` deliberately requires the sibling to be answered: "not X" is a statement about
+ * an answer, so an unanswered sibling does not satisfy it and the field stays locked.
+ */
+export const parseDependency = (
+  dependency: string
+): { name: string; op?: '=' | '!='; value?: string } => {
+  const neqIdx = dependency.indexOf('!=');
+  if (neqIdx !== -1) {
+    return {
+      name: dependency.substring(0, neqIdx),
+      op: '!=',
+      value: dependency.substring(neqIdx + 2),
+    };
+  }
+
+  const eqIdx = dependency.indexOf('=');
+  if (eqIdx !== -1) {
+    return {
+      name: dependency.substring(0, eqIdx),
+      op: '=',
+      value: dependency.substring(eqIdx + 1),
+    };
+  }
+
+  return { name: dependency };
+};
+
+/** Whether one dependency entry holds against the current form values. */
+const isDependencyFulfilled = (
+  dependency: string,
+  options: TQorusForm,
+  optionsSchema?: IQorusFormSchema
+): boolean => {
+  const { name, op, value } = parseDependency(dependency);
+
+  if (op) {
+    const optValue = options?.[name]?.value;
+    if (optValue == null) {
+      return false;
+    }
+    return op === '=' ? String(optValue) === value : String(optValue) !== value;
+  }
+
+  return options?.[name]
+    ? validateField(options[name].type, options[name].value, {
+        ...(optionsSchema?.[name] as unknown as IFieldValidationProps),
+        options,
+        optionSchema: optionsSchema,
+      })
+    : true;
+};
+
 export const hasAllDependenciesFullfilled = (
   dependencies: string[] | string[][],
   options: TQorusForm,
@@ -1819,38 +1881,19 @@ export const hasAllDependenciesFullfilled = (
   }
 
   return dependencies.every((dependency: string | string[]) => {
+    // A nested list is an ANY. It used to look each entry up as a whole form-field
+    // name, so a `name=value` entry inside one found no field and returned `true`
+    // unconditionally — the any-of group was satisfied by anything at all, while
+    // CompactRow's lock rendered those same entries as real comparisons. Both halves
+    // now go through one parser, so the grammar cannot mean two things.
     if (isArray(dependency)) {
-      return (dependency as string[]).some((dep) => {
-        return options?.[dep]
-          ? validateField(options[dep].type, options[dep].value, {
-              ...(optionsSchema?.[dep] as unknown as IFieldValidationProps),
-              options,
-              optionSchema: optionsSchema,
-            })
-          : true;
-      });
-    }
-
-    if (isString(dependency)) {
-      const eqIdx = (dependency as string).indexOf('=');
-      if (eqIdx !== -1) {
-        const depName = (dependency as string).substring(0, eqIdx);
-        const depValue = (dependency as string).substring(eqIdx + 1);
-        const optValue = options?.[depName]?.value;
-        return optValue != null && String(optValue) === depValue;
-      }
+      return (dependency as string[]).some((dep) =>
+        isDependencyFulfilled(dep, options, optionsSchema)
+      );
     }
 
-    return options?.[dependency as string]
-      ? validateField(
-          options[dependency as string].type,
-          options[dependency as string].value,
-          {
-            ...(optionsSchema?.[dependency as string] as unknown as IFieldValidationProps),
-            options,
-            optionSchema: optionsSchema,
-          }
-        )
+    return isString(dependency)
+      ? isDependencyFulfilled(dependency as string, options, optionsSchema)
       : true;
   });
 };

package/src/index.tsx

@@ -7,6 +7,7 @@ export {
   getTypeFromValue,
   maybeParseYaml,
   hasAllDependenciesFullfilled,
+  parseDependency,
   validateOptionWithRequiredGroups,
 } from './helpers/validations';
 export type { IValidationResult } from './helpers/validations';