@qoretechnologies/reqraft 0.10.53 → 0.10.54-pr.115.ge2d364c

package/src/components/form/expressions/builder/index.tsx

@@ -24,6 +24,7 @@ import React, { useCallback, useMemo, useRef, useState } from 'react';
 import styled from 'styled-components';
 import { moveItem } from '../../../../helpers/common';
 import { areQorusTypesCompatible, getArgumentType } from '../../../../helpers/expressions';
+import { addMissingExpressionArgs } from '../argumentPresence';
 import { findTemplate } from '../../../../helpers/templates';
 import { validateField, validateFieldWithResult } from '../../../../helpers/validations';
 import { IQorusTypeObject, useQorusTypes } from '../../../../hooks/useQorusTypes';
@@ -76,6 +77,18 @@ export interface IExpressionBuilderProps {
   expressions?: IExpressionSchema[];
   expressionsUrl?: string;
   serverHandled?: boolean;
+  /**
+   * SEAM (reqraft): the host's per-`ui_type` editors, forwarded to the operand
+   * fields below.
+   *
+   * Without them an operand whose type is one of the CONSUMER's own ui_types
+   * falls through `AutoFormField`'s switch to the literal "Unknown type!" tag.
+   * That is what an assertion's `Value` did the moment it was turned into an
+   * expression: the field is `test-reference`, an IDE ui_type whose editor the
+   * IDE registers through `componentOverrides`, and the builder rendered its
+   * operands without them.
+   */
+  componentOverrides?: Record<string, React.FC<any>>;
   size?: string;
   /**
    * SEAM (reqraft): extra hover actions prepended to each expression card —
@@ -129,6 +142,7 @@ export const Expression = ({
   expressionsUrl,
   serverHandled,
   extraActions,
+  componentOverrides,
   ...props
 }: IExpressionProps) => {
   const types = useQorusTypes();
@@ -264,58 +278,8 @@ export const Expression = ({
   );
 
   const addMissingArgs = useCallback(
-    (expression: string, args: IExpression[] = []): IExpression[] => {
-      const newArgs = [...args];
-      // Check if this expression has variable arguments
-      const selectedExpression = expressions.value?.find((exp) => exp.name === expression);
-
-      if (selectedExpression.varargs) {
-        if (selectedExpression.subtype === 2) {
-          newArgs.push({
-            is_expression: true,
-            value: {
-              args: [],
-            },
-          });
-        } else {
-          // Add the number of arguments equal to min_args - 1
-          newArgs.push(
-            ...Array.from({ length: selectedExpression.min_args - 1 }, () => ({
-              type:
-                selectedExpression.args[0].ui_type === 'richtext' ||
-                selectedExpression.args[0].ui_type === 'number'
-                  ? selectedExpression.args[0].ui_type
-                  : undefined,
-            }))
-          );
-        }
-      } else {
-        // Check if any of the arguments have a default value
-        selectedExpression.args.forEach((arg, index) => {
-          if (
-            newArgs[index] === undefined ||
-            size(newArgs[index]) === 0 ||
-            (arg.default_value && 'value' in newArgs[index] === false)
-          ) {
-            if (arg.default_value) {
-              newArgs[index] = {
-                value: arg.default_value,
-                type: arg.ui_type,
-              };
-            } else {
-              newArgs[index] = {
-                type:
-                  arg.ui_type === 'richtext' || arg.ui_type === 'number' || arg.ui_type === 'bool'
-                    ? arg.ui_type
-                    : undefined,
-              };
-            }
-          }
-        });
-      }
-
-      return newArgs;
-    },
+    (expression: string, args: IExpression[] = []): IExpression[] =>
+      addMissingExpressionArgs(expressions.value as never, expression, args as never) as never,
     [JSON.stringify(expressions.value)]
   );
 
@@ -501,13 +465,7 @@ export const Expression = ({
   );
 
   const updateArg = useCallback(
-    (
-      val: any,
-      index: number = 0,
-      type?: string,
-      isFunction?: boolean,
-      isRequired?: boolean
-    ) => {
+    (val: any, index: number = 0, type?: string, isFunction?: boolean) => {
       const args = clone(value.value.args);
       const newVal = clone(val);
 
@@ -515,12 +473,18 @@ export const Expression = ({
         newVal.args = addMissingArgs(newVal.exp, newVal.args);
       }
 
+      /* `required` is NOT written here. It is a schema key — it describes the
+         catalogue's declaration of the argument, not the author's value, and
+         nothing reads it back off a stored argument (validation takes it from
+         the schema). Persisting it made a cleared argument indistinguishable
+         from real data: the value dropped out as `undefined`, `required: true`
+         stayed, and what was saved to the draft was `{type, required}` — an
+         argument DEFINITION sitting where its value should be. */
       args[index] = {
         ...args[index],
         value: newVal,
         type: !isFunction ? type || args[index]?.type : undefined,
         is_expression: isFunction,
-        required: isRequired,
       };
 
       onValueChange(
@@ -683,16 +647,10 @@ export const Expression = ({
   const handleFirstParamChange = useCallback(
     (_name, value, type, isFunction) => {
       if (isFunction || (type !== 'any' && type !== 'auto')) {
-        updateArg(
-          value,
-          0,
-          isFunction ? undefined : type,
-          isFunction,
-          selectedExpression?.args?.[0]?.required
-        );
+        updateArg(value, 0, isFunction ? undefined : type, isFunction);
       }
     },
-    [updateArg, JSON.stringify(selectedExpression)]
+    [updateArg]
   );
 
   const buildCustomTemplateItems = useCallback(
@@ -1013,6 +971,7 @@ export const Expression = ({
           >
             <TemplateField
               component={auto}
+              componentOverrides={componentOverrides}
               // SEAM (reqraft): an operand that becomes an expression mounts
               // its own builder through this TemplateField — hand the host's
               // actions on, or nesting silently drops them (the group
@@ -1132,6 +1091,7 @@ export const Expression = ({
                     <TemplateField
                       minimal
                       component={auto}
+                      componentOverrides={componentOverrides}
                       // SEAM (reqraft): same as the first operand above.
                       extraActions={extraActions}
                       noSoft
@@ -1166,13 +1126,7 @@ export const Expression = ({
                         !!arg.default_value
                       }
                       onChange={((_name, value, type, isFunction) => {
-                        updateArg(
-                          value,
-                          index + 1,
-                          isFunction ? undefined : type,
-                          isFunction,
-                          arg.required
-                        );
+                        updateArg(value, index + 1, isFunction ? undefined : type, isFunction);
                       }) as any}
                       fluid={false}
                       fixed={true}
@@ -1248,6 +1202,7 @@ export const ExpressionBuilder = ({
   expressionsUrl,
   serverHandled,
   extraActions,
+  componentOverrides,
   reorder,
 }: IExpressionBuilderProps) => {
   const templates = useTemplates(!isChild, localTemplates);
@@ -1432,6 +1387,7 @@ export const ExpressionBuilder = ({
         id={level === 0 && index === 0 ? 'expression-builder' : undefined}
         serverHandled={serverHandled}
         extraActions={extraActions}
+        componentOverrides={componentOverrides}
         reorder={reorder}
       />
     </ReqoreErrorBoundary>

package/src/components/form/expressions/dpqlMockLsp.ts

@@ -19,8 +19,41 @@ interface IMockExprNode {
   is_expression?: boolean;
 }
 
+/**
+ * Every `dpql/parse` the mock answered, in order, for diagnosis.
+ *
+ * The type-analysis stories depend on the front end SENDING `target_type` —
+ * the mock returns analysis only when it is present, exactly as the server
+ * behaves. When one of those stories fails there are two very different
+ * causes, and the rendered DOM cannot tell them apart: the request never
+ * carried a target, or it did and the answer was not rendered. This records
+ * which, and the story reports it in its assertion message so the answer
+ * survives into a CI log.
+ */
+export interface IDpqlMockParseCall {
+  text: string;
+  target?: string;
+  analysed: boolean;
+}
+export const dpqlMockParseCalls: IDpqlMockParseCall[] = [];
+
+/** The template namespaces the server offers after a `$`. */
+const DPQL_MOCK_TEMPLATE_ITEMS = [
+  { label: '$data:', insertText: '$data:', kind: 1, detail: 'template' },
+  { label: '$config:', insertText: '$config:', kind: 1, detail: 'template' },
+  { label: '$static:', insertText: '$static:', kind: 1, detail: 'template' },
+  { label: '$timestamp:', insertText: '$timestamp:', kind: 1, detail: 'template' },
+];
+
+/** The record fields the server offers after an `@`. */
+const DPQL_MOCK_FIELD_ITEMS = [
+  { label: '@name', insertText: '@name', kind: 5, detail: 'string' },
+  { label: '@status', insertText: '@status', kind: 5, detail: 'string' },
+];
+
 /** Start the mock LSP; returns a teardown function. */
 export const startDpqlMockLsp = (): (() => void) => {
+  dpqlMockParseCalls.length = 0;
   const lsp = createMockLspServer(MOCK_LSP_URL, {
     capabilities: {
       textDocumentSync: { openClose: true, change: 2 },
@@ -29,7 +62,25 @@ export const startDpqlMockLsp = (): (() => void) => {
     // Unknown requests get an empty success so nothing hangs.
     defaultResult: {},
     handlers: {
-      'textDocument/completion': () => ({ isIncomplete: false, items: [] }),
+      /* Position-aware, as the real server is: `$` opens the template
+         namespaces, `@` the record fields. Answering the same list whatever
+         precedes the cursor would make a story asserting the `$` menu pass
+         for a shell that asked in the wrong context — which is the only thing
+         such a story is there to catch. (`DpqlEditor`'s own stories carry the
+         full catalogue; this is the minimal subset.) */
+      'textDocument/completion': (msg, server) => {
+        const position = msg.params?.position ?? { line: 0, character: 0 };
+        const line = server.documentText.split('\n')[position.line] ?? '';
+        const head = line.slice(0, position.character);
+        const sigil = head.match(/[@$][\w:.{}]*$/)?.[0]?.[0] ?? '';
+        if (sigil === '$') {
+          return { isIncomplete: false, items: DPQL_MOCK_TEMPLATE_ITEMS };
+        }
+        if (sigil === '@') {
+          return { isIncomplete: false, items: DPQL_MOCK_FIELD_ITEMS };
+        }
+        return { isIncomplete: false, items: [] };
+      },
 
       'textDocument/semanticTokens/full': () => ({ data: [] }),
 
@@ -39,6 +90,34 @@ export const startDpqlMockLsp = (): (() => void) => {
       // deterministic and verifiable.
       'dpql/parse': (msg) => {
         const text = (msg.params?.text ?? '').trim();
+        // Type analysis is returned ONLY when the request carried a
+        // `target_type`, exactly as the server behaves. That makes it a real
+        // check rather than a fixture: a front end that stops sending the
+        // target gets no analysis, and the stories asserting the message go
+        // red instead of quietly passing.
+        const target = msg.params?.target_type as string | undefined;
+        const inferred = 'string';
+        const analysis =
+          target ?
+            {
+              inferred_type: inferred,
+              target_type: target,
+              type_compatible: target === inferred || target === 'auto',
+              auto_coercible: true,
+              // "text used as a number" is the attempted-but-not-guaranteed
+              // conversion; "text used as text" needs no conversion at all.
+              coercion_may_fail: target === 'int' || target === 'float',
+              suggested_fix:
+                target === inferred || target === 'auto' ?
+                  undefined
+                : { text: `to${target[0].toUpperCase()}${target.slice(1)}(${text})` },
+            }
+          : {};
+        dpqlMockParseCalls.push({
+          text,
+          target,
+          analysed: !!target,
+        });
         return {
           success: true,
           expression: {
@@ -51,6 +130,7 @@ export const startDpqlMockLsp = (): (() => void) => {
               ],
             },
           },
+          ...analysis,
           diagnostics: [],
         };
       },

package/src/components/form/expressions/renderExpressionToText.ts

@@ -10,6 +10,67 @@ import { IExpression, IExpressionSchema, IExpressionValue } from './types';
 const isOperatorSymbol = (symbol?: string): boolean =>
   !!symbol && /^[^\w\s]+$/.test(symbol);
 
+/**
+ * Operator precedence, lower binds tighter.
+ *
+ * Mirrors `DpqlOperatorPrecedence` in the Qore DataProvider module, which is
+ * the source of truth — the server renders the same ASTs through
+ * `DataProvider::renderExpression`, and an offline fallback that parenthesised
+ * differently would make the same expression read two ways depending on
+ * whether the instance happened to be reachable.
+ */
+const PRECEDENCE: Record<string, number> = {
+  '*': 1,
+  '/': 1,
+  '%': 1,
+  '+': 2,
+  '-': 2,
+  '!': 3,
+  '==': 4,
+  '!=': 4,
+  '<': 4,
+  '<=': 4,
+  '>': 4,
+  '>=': 4,
+  '&&': 5,
+  '||': 6,
+};
+
+/** Anything that is not an operator; nothing binds tighter. */
+const PREC_PRIMARY = 0;
+/** Looser than every operator, so a value rendered in it is never wrapped. */
+const PREC_LOOSEST = 7;
+
+/**
+ * Operators whose grouping cannot change the result.
+ *
+ * `+` is deliberately absent: it concatenates when an operand is a string, so
+ * `1 + (2 + "a")` is `"12a"` where `1 + 2 + "a"` is `"3a"`. Dropping its
+ * parentheses would not be a cosmetic simplification.
+ */
+const ASSOCIATIVE = new Set(['&&', '||']);
+
+const precedenceOf = (exp?: string): number => PRECEDENCE[exp ?? ''] ?? PREC_PRIMARY;
+
+/**
+ * The context an operator's argument is rendered in — the same rule as
+ * `DpqlSerializer::getArgumentContext()`.
+ *
+ * The first argument is where left-associative parsing puts a same-precedence
+ * child back, so it needs no parentheses; a later one does, or `1 - (2 - 3)`
+ * reads as `1 - 2 - 3`, which is a different expression.
+ */
+const argumentContext = (exp: string, argn: number): number => {
+  const prec = precedenceOf(exp);
+  return !argn || ASSOCIATIVE.has(exp) ? prec : prec - 1;
+};
+
+/** An argument reaches this as a bare value or as a `{type, value}` envelope. */
+const readArgValue = (arg: unknown): unknown =>
+  arg !== null && typeof arg === 'object' && 'value' in (arg as object)
+    ? (arg as { value: unknown }).value
+    : arg;
+
 const renderLiteral = (value: unknown): string => {
   if (value === undefined || value === null) return 'null';
   if (typeof value === 'string') return JSON.stringify(value);
@@ -17,31 +78,59 @@ const renderLiteral = (value: unknown): string => {
   return String(value);
 };
 
-/**
- * Recursively render an expression AST to readable text — the client-side
- * approximation, used as the fallback when the LSP is unreachable.
- */
-export const renderExpressionToText = (
+/** Renders `value` and wraps it only if it binds looser than `contextPrec`. */
+const renderInContext = (
   value: IExpressionValue | undefined,
-  expressions: IExpressionSchema[] = []
+  expressions: IExpressionSchema[],
+  contextPrec: number
 ): string => {
   if (!value?.exp) return '';
+  /* A `value` expression IS its literal.
+  
+     It is the wrapper the parser puts around a bare literal — typing `null`,
+     or `42`, into the text editor produces one — and it carries no symbol, so
+     rendering it through the generic paths printed the wrapper instead of the
+     value: `value(42)` with a catalogue that names it, `(42)` with one that
+     supplies its empty symbol. The server renders the literal alone, and a
+     summary that disagrees with the preview beside it is worse than either. */
+  if (value.exp === 'value' && (value.args ?? []).length === 1) {
+    const only = (value.args ?? [])[0] as IExpression;
+    if (!only?.is_expression) {
+      return renderLiteral(readArgValue(only));
+    }
+  }
   const schema = expressions.find((e) => e.name === value.exp);
   const symbol = schema?.symbol ?? value.exp;
-  const args = (value.args ?? []).map((arg: IExpression) =>
+  const args = value.args ?? [];
+  // Logical group (subtype 2) → join with the symbol.
+  const isLogicalGroup = schema?.subtype === 2 || value.exp === '&&' || value.exp === '||';
+  // Binary operator → infix. Everything else renders as a call, whose own
+  // parentheses and commas already delimit its arguments.
+  const isInfix = isLogicalGroup || (args.length === 2 && isOperatorSymbol(symbol));
+
+  const parts = args.map((arg: IExpression, argn: number) =>
     arg?.is_expression && arg.value?.exp
-      ? `(${renderExpressionToText(arg.value, expressions)})`
+      ? renderInContext(
+          arg.value,
+          expressions,
+          isInfix ? argumentContext(value.exp as string, argn) : PREC_LOOSEST
+        )
       : renderLiteral(arg?.value)
   );
 
-  // Logical group (subtype 2) → join with the symbol.
-  if (schema?.subtype === 2 || value.exp === '&&' || value.exp === '||') {
-    return args.join(` ${symbol} `);
+  if (!isInfix) {
+    return `${symbol}(${parts.join(', ')})`;
   }
-  // Binary operator → infix.
-  if (args.length === 2 && isOperatorSymbol(symbol)) {
-    return `${args[0]} ${symbol} ${args[1]}`;
-  }
-  // Otherwise function form.
-  return `${symbol}(${args.join(', ')})`;
+
+  const text = isLogicalGroup ? parts.join(` ${symbol} `) : `${parts[0]} ${symbol} ${parts[1]}`;
+  return precedenceOf(value.exp) > contextPrec ? `(${text})` : text;
 };
+
+/**
+ * Recursively render an expression AST to readable text — the client-side
+ * approximation, used as the fallback when the LSP is unreachable.
+ */
+export const renderExpressionToText = (
+  value: IExpressionValue | undefined,
+  expressions: IExpressionSchema[] = []
+): string => renderInContext(value, expressions, PREC_LOOSEST);

package/src/components/form/fields/Field.tsx

@@ -2,7 +2,6 @@ import {
   IReqoreLabelProps,
   ReqoreCheckbox,
   ReqoreControlGroup,
-  ReqoreSkeleton,
   ReqoreSpan,
 } from '@qoretechnologies/reqore';
 import { IWithReqoreSize } from '@qoretechnologies/reqore/dist/types/global';
@@ -38,6 +37,7 @@ import { IDataSchemaDefinition } from './schema-definition/types';
 // Direct import — circular dep (FormEngine → TemplateField → FormField → FormEngine) is safe
 // because modules are all loaded before any component renders
 import { FormEngine } from '../engine/FormEngine';
+import { FormFieldsSkeleton } from '../engine/FormFieldsSkeleton';
 
 /** Soft Qore types (softint, softstring, …) render as their concrete base —
  * the soft/hard distinction is value-level, not UI. */
@@ -345,7 +345,8 @@ export const FormField = <T extends TFormFieldType>({
 
       case 'hash': {
         if (argSchemaLoading) {
-          return <ReqoreSkeleton height='80px' />;
+          // A hash renders a nested FORM, so it waits in the shape of one.
+          return <FormFieldsSkeleton rows={2} />;
         }
         if (finalArgSchema) {
           return (

package/src/components/form/fields/allowed-values/AllowedValues.tsx

@@ -40,13 +40,23 @@ const DISALLOW_COMPACT_AO_TYPES = ['connection'];
  * Whether a creatable field's value is carried by the chip picker rather than
  * by a raw editor with a suggestion list beside it.
  *
- * `string` only, and only with something to suggest. Every other shape a
+ * String-valued only, and only with something to suggest. Every other shape a
  * creatable field can declare either does not fit a one-line chip (a document
  * — `long-string`, `binary`, `data`; a hash; a list) or would come back out of
  * one as a string (a number, a date), and a field with nothing to offer is
  * better served by the editor it has always had. Those keep today's rendering:
  * the raw editor, with the saved-and-suggested picker under it.
  *
+ * `select-string` counts, and leaving it out was the bug. A picker field
+ * declares its storage type (`*string`) and its `ui_type` (`select-string`),
+ * and by the time a schema reaches here the two have been flattened to one:
+ * `type` arrives as `select-string`. So this returned false for every such
+ * field and NEITHER renderer stood down — the picker drew the value, and the
+ * saved-and-suggested list drew the same candidates again underneath it. A
+ * test's Service and Method fields showed 183 and 7 items twice over, in two
+ * controls that set one value. A select-string's value IS a string and fits the
+ * chip, which is the only thing this predicate is really asking.
+ *
  * Both the renderer of the picker (`FieldAllowedValues`) and the renderer of
  * the raw editor (`AutoFormField`, `FormField`) ask this, so that exactly one
  * of them draws the value.
@@ -55,7 +65,8 @@ export const rendersCreatableValueSelect = (
   type?: string,
   allowCreation?: boolean,
   items?: unknown[]
-): boolean => !!allowCreation && type === 'string' && count(items) > 0;
+): boolean =>
+  !!allowCreation && (type === 'string' || type === 'select-string') && count(items) > 0;
 
 export const FieldAllowedValuesCheckGroup = memo(
   ({

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

@@ -7,7 +7,6 @@ import {
   ReqoreControlGroup,
   ReqoreErrorBoundary,
   ReqoreMessage,
-  ReqoreSpinner,
   ReqoreTag,
 } from '@qoretechnologies/reqore';
 import { IReqoreFormTemplates } from '@qoretechnologies/reqore/dist/components/Textarea';
@@ -53,6 +52,7 @@ import { IDataSchemaDefinition } from '../schema-definition/types';
 import { ISelectFormFieldItem, SelectFormField } from '../select/Select';
 import { StringFormField } from '../string/String';
 import { UrlFormField } from '../url/Url';
+import { FormFieldsSkeleton } from '../../engine/FormFieldsSkeleton';
 
 /** UI superset of `TQorusType` — the IDE's `Field/systemOptions` `IQorusType`. */
 export type IQorusType = TQorusType | string;
@@ -395,6 +395,13 @@ function AutoField<T = any>({
         arg_schema={arg_schema}
         element_type={element_type}
         ui_element_type={ui_element_type}
+        // Same reason as the three above: it is destructured out of `rest` so the
+        // primitive renderers do not spread it onto a DOM node, which also took
+        // it away from host editors — and a host editor is exactly what
+        // `inherit_props` exists to feed. A field declaring it got the values
+        // resolved and then had nowhere to send them, so every consumer
+        // downstream saw `undefined` and silently did nothing.
+        inheritedFromParent={inheritedFromParent}
         name={name}
         value={value}
         onChange={(val: any, emittedType?: IQorusType, emittedIsFunction?: boolean) => {
@@ -457,7 +464,10 @@ function AutoField<T = any>({
   }
 
   if (arg_schema && !finalArgSchema) {
-    return <ReqoreSpinner size='small'>Loading field data...</ReqoreSpinner>;
+    /* One ROW, because this stands in for one field. It was a spinner reading
+       "Loading field data…", which is a different picture from every other
+       wait on the page and announces a delay the reader cannot act on. */
+    return <FormFieldsSkeleton rows={1} />;
   }
 
   const renderAllowedValues = (currentType: IQorusType) => {