@qoretechnologies/reqraft 0.10.57 → 0.10.58-pr.129.g2af0cf5

package/src/helpers/expressions.ts

@@ -100,3 +100,28 @@ export const areQorusTypesCompatible = (
   // If none of the types are compatible return false
   return false;
 };
+
+/**
+ * Whether an operation is offered where its result must be of `returnType`: a condition (`bool`) is
+ * built from the operations that give true or false, not from every operation the server has.
+ *
+ * Only a condition narrows the list. Any other type keeps every operation: a value of one type is often
+ * made from an operation that gives another (text from rich text, a number from an int), and the
+ * mismatch message after the choice says when it does not fit.  An operation whose result is known
+ * only once it is built (`any`, or the type of its first argument) is offered everywhere.
+ */
+export const expressionFitsReturnType = (
+  returnType: string | string[] | undefined,
+  expression: { ui_return_type?: string; return_type_first_arg?: boolean }
+): boolean => {
+  const types = isArray(returnType) ? returnType : returnType ? [returnType] : [];
+  const condition = types.length > 0 && types.every((type) => /^\*?(bool|boolean)$/.test(type));
+  if (!condition) {
+    return true;
+  }
+  const result = expression.ui_return_type;
+  if (expression.return_type_first_arg || !result || result === 'any' || result === 'auto') {
+    return true;
+  }
+  return /^\*?(bool|boolean)$/.test(result);
+};

package/src/helpers/validations.ts

@@ -16,6 +16,7 @@ import { isOptionInterfaceUiType } from './optionUiTypes';
 import { getListElementValue, getOptionsFromRequiredGroups } from './options';
 import { IProviderType, TVariableActionValue, maybeBuildOptionProvider } from './providerValue';
 import { getTemplateKey, getTemplateValue, isValueTemplate } from './templates';
+import { getUnlistedChoiceReason } from './allowedValues';
 
 /** The five cron fields, in order, as a schedule hash may name them. */
 const CRON_FIELDS: [string, string][] = [
@@ -309,6 +310,21 @@ export const _validateField = (
     }
   }
 
+  // A value that is not one of the field's fixed choices is INVALID — never
+  // erased. The form used to drop such a value when the choices arrived, and
+  // three times the dropped value was a real one (a document naming a choice,
+  // a bare-declared choice, a value whose choices had not loaded yet) that the
+  // emptied form then saved. Keeping it and saying why it cannot be submitted
+  // leaves the author to decide. Templates and expression values returned
+  // above; `allowed_values: []` and creatable choices are not judged. An
+  // `expression` is never judged either: the expression branch above recurses
+  // here with the field's schema (choices included) and the AST as the value.
+  const unlistedChoiceReason =
+    type === 'expression' ? undefined : getUnlistedChoiceReason(value, field);
+  if (unlistedChoiceReason) {
+    return invalidResult(unlistedChoiceReason);
+  }
+
   // An interface type names another Qorus object by its name, so a non-empty
   // string is the whole contract. `connection` is the exception: it carries
   // enablement and authentication state of its own, checked below.

package/src/utils/fetch.ts

@@ -12,6 +12,10 @@ export interface IReqraftFetchResponse<T> {
   data: T;
   ok: boolean;
   code?: number;
+  /**
+   * Set on every non-ok response: the HTTP reason phrase, or `HTTP <status>`
+   * when there is none (always the case over HTTP/2).
+   */
   error?: any;
   /**
    * The parsed error body on a non-ok response, when the server sent JSON.
@@ -335,7 +339,12 @@ export async function query<T>({
       data: requestData.data,
       ok: false,
       code: requestData.status,
-      error: requestData.statusText,
+      // Never empty: HTTP/2 has no reason phrase, so `statusText` is always ''
+      // there, and an empty `error` reads as "no error" to every caller that
+      // tests it for truthiness - `useFetch` consumers then saw a failed request
+      // as one still loading, forever (a 403 left a dashboard panel on its
+      // skeleton).
+      error: requestData.statusText || `HTTP ${requestData.status}`,
       // Only when the body really was JSON: `data` is `{}` for a non-JSON body,
       // and an empty object masquerading as a parsed error tells a caller
       // nothing while looking like it did.