@qoretechnologies/reqraft 0.10.46-pr.95.ge595a13 → 0.10.46

package/src/components/searchFilterBar/SearchFilterBar.stories.tsx

@@ -0,0 +1,62 @@
+import { StoryObj } from '@storybook/react-vite';
+import { expect, fn, within } from 'storybook/test';
+
+import { StoryMeta } from '../../types';
+import { SearchFilterBar } from './SearchFilterBar';
+
+/*
+ * The strip that sits above a list and narrows it: a search box plus the filter
+ * dropdowns that go with it.
+ */
+const meta = {
+  component: SearchFilterBar,
+  title: 'Components/Search Filter Bar',
+  args: {
+    onChange: fn(),
+    placeholder: 'Search tickets…',
+    filters: [
+      {
+        icon: 'Filter3Line' as const,
+        label: 'Any status',
+        items: [
+          { label: 'Any status', value: 'any', selected: true },
+          { label: 'Open', value: 'open' },
+          { label: 'Resolved', value: 'resolved' },
+        ],
+      },
+    ],
+  },
+} as StoryMeta<typeof SearchFilterBar>;
+
+export default meta;
+type Story = StoryObj<typeof meta>;
+
+export const Idle: Story = {
+  args: { value: '' },
+  parameters: {
+    docs: {
+      description: {
+        story: 'Nothing typed — the bar is quiet, and the list below it is the whole list.',
+      },
+    },
+  },
+  play: async ({ canvasElement }) => {
+    expect(within(canvasElement).getByPlaceholderText('Search tickets…')).toBeVisible();
+  },
+};
+
+export const Filtering: Story = {
+  args: { value: 'deploy', intent: 'info' },
+  parameters: {
+    docs: {
+      description: {
+        story:
+          'A query is active, so the box carries `intent="info"`. Without it a filtered list and a genuinely short list look identical, and a reader who lands on three rows cannot tell which they are looking at.',
+      },
+    },
+  },
+  play: async ({ canvasElement }) => {
+    const input = within(canvasElement).getByPlaceholderText('Search tickets…');
+    expect(input).toHaveValue('deploy');
+  },
+};

package/src/components/searchFilterBar/SearchFilterBar.tsx

@@ -1,4 +1,5 @@
 import { ReqoreControlGroup, ReqoreDropdown, ReqoreInput } from '@qoretechnologies/reqore';
+import { TReqoreIntent } from '@qoretechnologies/reqore/dist/constants/theme';
 import { IReqoreIconName } from '@qoretechnologies/reqore/dist/types/icons';
 import styled, { css } from 'styled-components';
 
@@ -70,6 +71,16 @@ export interface ISearchFilterBarProps {
    * panel (the References tab); a bar above a page-level list does not need it.
    */
   sticky?: boolean;
+  /**
+   * Intent for the search box.
+   *
+   * A bar that is narrowing the list should look different from one that is
+   * not — otherwise a reader who arrives at a short list cannot tell whether it
+   * is short or filtered. Callers pass `'info'` while a query is active. Left
+   * to the caller rather than derived from `value`, because a caller may hold
+   * other filter state this component never sees.
+   */
+  intent?: TReqoreIntent;
 }
 
 export const SearchFilterBar = ({
@@ -79,6 +90,7 @@ export const SearchFilterBar = ({
   filters = [],
   stacked,
   sticky,
+  intent,
 }: ISearchFilterBarProps) => (
   <Container $sticky={sticky}>
     {/* `size='small'` on the GROUP, not per control: the bar filters the content, it
@@ -98,6 +110,7 @@ export const SearchFilterBar = ({
         value={value}
         onChange={(event) => onChange((event.currentTarget as HTMLInputElement).value)}
         onClearClick={value ? () => onChange('') : undefined}
+        intent={intent}
         minimal
         fluid
       />

package/src/components/ticketThread/TicketThread.tsx

@@ -198,6 +198,13 @@ const StyledSkeletonThread = styled.div`
   gap: 12px;
   width: 100%;
   min-height: 100%;
+  /* A real message carries its own bubble, so it never touches the host's edge.
+     The skeleton is bare bars, and without this its avatars and lines were
+     pressed flat against the border of whatever holds the thread — which reads
+     as a clipped render rather than as loading. border-box so the padding comes
+     out of the 100% rather than adding to it. */
+  box-sizing: border-box;
+  padding: 12px;
 `;
 
 const StyledSkeletonRow = styled.div<{ $self: boolean }>`

package/src/helpers/common.ts

@@ -1,5 +1,5 @@
 import { IReqoreRichTextEditorProps } from '@qoretechnologies/reqore/dist/components/RichTextEditor';
-import { TQorusFormFieldSchema } from '@qoretechnologies/ts-toolkit';
+import { TQorusFormFieldSchema, TQorusFormOperatorValue } from '@qoretechnologies/ts-toolkit';
 import yaml from 'js-yaml';
 
 // ─── Typed ↔ YAML helpers ──────────────────────────────────────────────────────
@@ -163,6 +163,16 @@ export const richtextToSegments = (
   return segments;
 };
 
+/**
+ * An operator value as the list it logically is.
+ *
+ * An option's `op` holds either one operator or a chain of them, and both
+ * spellings are legitimate on the wire. Every reader wants the list.
+ */
+export const fixOperatorValue = (
+  operator: TQorusFormOperatorValue
+): (string | null | undefined)[] => (Array.isArray(operator) ? operator : [operator]);
+
 export const insertAtIndex = (array: any[] = [], index = 0, value: any): any[] => {
   return [...array.slice(0, index), value, ...array.slice(index)];
 };

package/src/helpers/expressions.ts

@@ -46,14 +46,28 @@ export const argumentMatchesType = (
   );
 };
 
+/**
+ * `auto` is the codebase's other spelling of `any` — `Field.tsx` maps both to
+ * one renderer, and FormEngine tests `type === 'any' || type === 'auto'` in
+ * several places — but the TYPES LIST only carries `any`.
+ *
+ * That mattered here because an unknown main type falls into the "not found"
+ * branch below and answers FALSE for every check. So an `auto`-typed field was
+ * judged incompatible with everything: `filterTemplatesByType()` removed every
+ * template from it, and the picker offered a group header with nothing under
+ * it. The field was not "a field with no templates" — it was a field whose
+ * templates had all been filtered away by a name mismatch.
+ */
+const normalizeAnyLikeTypeName = (name: string): string => (name === 'auto' ? 'any' : name);
+
 export const areQorusTypesCompatible = (
   mainType: string | string[],
   checkType: string | string[],
   fallbackTypes?: IQorusTypeObject[]
 ): boolean => {
   const types = getQorusTypes() || fallbackTypes || defaultQorusTypes;
-  const mainTypes = isArray(mainType) ? mainType : [mainType];
-  const checkTypes = isArray(checkType) ? checkType : [checkType];
+  const mainTypes = (isArray(mainType) ? mainType : [mainType]).map(normalizeAnyLikeTypeName);
+  const checkTypes = (isArray(checkType) ? checkType : [checkType]).map(normalizeAnyLikeTypeName);
   // Get each of the main types from the types list
   for (const main of mainTypes) {
     // Get the type object from the types

package/src/helpers/optionUiTypes.ts

@@ -0,0 +1,161 @@
+/**
+ * The Qorus option `ui_type` vocabulary.
+ *
+ * A `ui_type` names the widget an option is rendered with, and — because the
+ * widget decides what a complete value looks like — it is also what
+ * `validateField` switches on. Both readers have to agree about which strings
+ * are in the vocabulary, so the lists live here rather than beside either one.
+ *
+ * Grouped by what the group means to a reader, not by alphabet: the scalar
+ * types hold a single value, the collection types hold several, the choice
+ * types pick from a supplied set, and the interface types name another Qorus
+ * object by its name — which is why `isOptionInterfaceUiType` is enough for
+ * validation to treat the whole group as a non-empty string.
+ */
+
+export const OPTION_SCALAR_UI_TYPES = [
+  'string',
+  'long-string',
+  'data',
+  'binary',
+  'richtext',
+  'bool',
+  'boolean',
+  'date',
+  'int',
+  'integer',
+  'float',
+  'number',
+  'byte-size',
+  // an integer count of milliseconds rendered through the unit-aware timeout
+  // field; `validateField` has carried a dedicated `case 'timeout'` since the
+  // connection-options work, and a type the validator has a branch for must be
+  // in the vocabulary the same switch is keyed on — consumers ask
+  // `isOptionUiType` before they ever reach the validator, and an unlisted
+  // type reads as unknown (qorus-ide's timeout field regressed exactly this
+  // way when its local registry copy was consolidated onto this one).
+  'timeout',
+  'url',
+  'code-editor',
+  'rgbcolor',
+  'any',
+  'auto',
+  // semantic string formats (string-backed types that carry a UI-renderable identity; see the qore
+  // DataProvider QoreStringFormatDataType)
+  'email',
+  'uri',
+  'uuid',
+  'hostname',
+  'ipv4',
+  'ipv6',
+  'phone',
+] as const;
+
+export const OPTION_COLLECTION_UI_TYPES = [
+  'hash',
+  'free-hash',
+  'list',
+  'free-list',
+  'option_hash',
+  'file',
+  'file-as-string',
+  'collection-documents',
+] as const;
+
+export const OPTION_CHOICE_UI_TYPES = [
+  'enum',
+  'select-string',
+  'select-array',
+  'multi-select',
+] as const;
+
+export const OPTION_INTERFACE_UI_TYPES = [
+  'workflow',
+  'service',
+  'job',
+  'connection',
+  'mapper',
+  'class',
+  'value-map',
+  'fsm',
+  'qog',
+  'api-schema',
+  'auth-profile',
+  'ai-collection',
+  'ai-endpoint',
+  'ai-guardrail',
+  'ml-model',
+  'release-config',
+  'alertrule',
+  'alertsilence',
+  'installed-release',
+  'business-process',
+  'schema',
+  'test',
+] as const;
+
+export const OPTION_CUSTOM_UI_TYPES = [
+  'processor',
+  'processor-mappings',
+  'data-provider',
+  'tool-catalog',
+  'schema-definition',
+  'test-cases',
+  'test-value-contract',
+  'dpql',
+  'active-windows',
+] as const;
+
+export const OPTION_UI_TYPES = [
+  ...OPTION_SCALAR_UI_TYPES,
+  ...OPTION_COLLECTION_UI_TYPES,
+  ...OPTION_CHOICE_UI_TYPES,
+  ...OPTION_INTERFACE_UI_TYPES,
+  ...OPTION_CUSTOM_UI_TYPES,
+] as const;
+
+export type TOptionUiType = (typeof OPTION_UI_TYPES)[number];
+export type TOptionInterfaceUiType = (typeof OPTION_INTERFACE_UI_TYPES)[number];
+
+export const LEGACY_FIELD_UI_TYPES = [
+  'api-manager',
+  'array',
+  'array-auto',
+  'array-of-pairs',
+  'class-array',
+  'class-connectors',
+  'constant-array',
+  'context-selector',
+  'cron',
+  'data-provider-options',
+  'file-array',
+  'fsm-list',
+  'function-array',
+  'http-content',
+  'method-name',
+  'opcua-method-arguments',
+  'opcua-write-values',
+  'options',
+  'select',
+  'service-events',
+  'service-webhooks',
+  'type-selector',
+] as const;
+
+export const KNOWN_QORUS_UI_TYPES = [...OPTION_UI_TYPES, ...LEGACY_FIELD_UI_TYPES] as const;
+
+export type TLegacyFieldUiType = (typeof LEGACY_FIELD_UI_TYPES)[number];
+export type TKnownQorusUiType = (typeof KNOWN_QORUS_UI_TYPES)[number];
+
+const optionUiTypeSet = new Set<string>(OPTION_UI_TYPES);
+const interfaceUiTypeSet = new Set<string>(OPTION_INTERFACE_UI_TYPES);
+const knownQorusUiTypeSet = new Set<string>(KNOWN_QORUS_UI_TYPES);
+
+export const isOptionUiType = (type: unknown): type is TOptionUiType =>
+  typeof type === 'string' && optionUiTypeSet.has(type);
+
+export const isOptionInterfaceUiType = (type: unknown): type is TOptionInterfaceUiType =>
+  typeof type === 'string' && interfaceUiTypeSet.has(type);
+
+export const isKnownQorusUiType = (type: unknown): type is TKnownQorusUiType =>
+  typeof type === 'string' && knownQorusUiTypeSet.has(type);

package/src/helpers/options.ts

@@ -29,3 +29,26 @@ export const getRequiredOptionMessage = (
 
   return `This field or ${requiredOptions} is required`;
 };
+
+/**
+ * The value of one element of a list field.
+ *
+ * A list element arrives in either of two shapes, and both are legitimate. The
+ * editor keeps each element in a `{value, type}` envelope while the form is
+ * being worked on — that is what `formatToServerValue` writes — while a value
+ * read back from storage holds what the server contract asks for, which for a
+ * list of strings is the bare strings.
+ *
+ * Reaching straight for `.value` answered `undefined` for every stored element.
+ * On a read that emptied the row; on a validation pass it failed the element as
+ * empty; and on an autosaving form the emptiness was then written back over the
+ * stored value. One helper so the readers cannot disagree about which shape
+ * they are looking at.
+ *
+ * An array is never an envelope — a rich-text document is itself an array, and
+ * `'value' in []` is false anyway, but saying so keeps the intent legible.
+ */
+export const getListElementValue = (element: unknown): unknown =>
+  element && typeof element === 'object' && !Array.isArray(element) && 'value' in element ?
+    (element as { value: unknown }).value
+  : element;

package/src/helpers/providerValue.ts

@@ -0,0 +1,125 @@
+import { TQorusForm } from '@qoretechnologies/ts-toolkit';
+
+export type TRecordType = 'search' | 'search-single' | 'create' | 'update' | 'delete';
+export type TRealRecordType = 'read' | 'create' | 'update' | 'delete';
+
+export type TProviderTypeSupports = {
+  [key in `supports_${TRealRecordType}`]?: boolean;
+};
+
+export type TProviderTypeArgs = {
+  [key in `${TRecordType}_args`]?: TQorusForm | TQorusForm[];
+};
+
+/**
+ * A data-provider selection, in the shape the form holds it.
+ *
+ * The `supports_*` flags say which record operations the selected provider can
+ * perform; validation reads them to decide whether a provider is a legitimate
+ * target for the operation the field was configured for.
+ */
+export interface IProviderType extends TProviderTypeSupports, TProviderTypeArgs {
+  type: string;
+  name: string;
+  path?: string;
+  options?: TQorusForm;
+  subtype?: 'request' | 'response';
+  hasApiContext?: boolean;
+  optionsChanged?: boolean;
+  searchOptionsChanged?: boolean;
+  desc?: string;
+  use_args?: boolean;
+  args?: any;
+  up?: boolean;
+  supports_request?: boolean;
+  supports_messages?: 'ASYNC' | 'SYNC' | 'NONE';
+  supports_observable?: boolean;
+  transaction_management?: boolean;
+  record_requires_search_options?: boolean;
+  create_args_freeform?: TQorusForm[];
+  is_api_call?: boolean;
+  search_options?: TQorusForm;
+  descriptions?: string[];
+  message_id?: string;
+  message?: {
+    type: string;
+    value: any;
+  };
+}
+
+/**
+ * A provider value as an object, from either representation a caller may hold.
+ *
+ * A provider reaches the form either already expanded into `IProviderType`, or
+ * as the flat path string the server stores — `"factory/db{driver=pgsql}/table"`
+ * or the plain `"type/name/path"`. Returns `null` for anything that is neither,
+ * so a caller reports an invalid value rather than reading fields off nothing.
+ */
+export const maybeBuildOptionProvider = (provider: unknown): IProviderType | null => {
+  if (!provider) {
+    return null;
+  }
+  if (typeof provider === 'object') {
+    return provider as IProviderType;
+  }
+  if (typeof provider !== 'string') {
+    return null;
+  }
+
+  if (provider.startsWith('factory')) {
+    const fixedProvider = provider.endsWith('/') ? provider : `${provider}/`;
+    const [factoryType] = fixedProvider.split('/');
+    const factoryName = fixedProvider.substring(
+      fixedProvider.indexOf('/') + 1,
+      fixedProvider.lastIndexOf('{')
+    );
+    const options = fixedProvider.substring(
+      fixedProvider.indexOf('{') + 1,
+      fixedProvider.lastIndexOf('}')
+    );
+    const optionsObject = options
+      .split(',')
+      .filter(Boolean)
+      .reduce<Record<string, string>>((result, option) => {
+        const [key, value] = option.split('=');
+        result[key] = value;
+        return result;
+      }, {});
+    const result: IProviderType = {
+      type: factoryType,
+      name: factoryName,
+      path: fixedProvider.substring(fixedProvider.lastIndexOf('}/') + 2),
+      options: optionsObject as unknown as TQorusForm,
+    };
+    if (provider.includes('?options_changed')) {
+      result.optionsChanged = true;
+    }
+    return result;
+  }
+
+  const [type, name, ...path] = provider.split('/');
+  return { type, name, path: path.join('/') };
+};
+
+/**
+ * An FSM variable action — which variable, and what is done to it.
+ *
+ * The provider half is `Partial<IProviderType>` because the action's own
+ * `action_type` decides which provider fields have to be there; validation
+ * re-runs the matching provider validator over the merged value rather than
+ * duplicating those rules here.
+ */
+export type TVariableActionValue = {
+  var_type: 'globalvar' | 'localvar' | 'autovar';
+  var_name: string;
+  transaction_action?: 'commit' | 'rollback' | 'begin-transaction';
+  action_type?:
+    | 'search'
+    | 'search-single'
+    | 'update'
+    | 'create'
+    | 'delete'
+    | 'transaction'
+    | 'send-message'
+    | 'apicall';
+} & Partial<IProviderType>;

package/src/helpers/singleLineString.ts

@@ -0,0 +1,61 @@
+/**
+ * Which string field types hold one line, and how to keep them that way.
+ *
+ * The server already draws this distinction and the IDE was throwing it away:
+ * a service's `name` is declared `ui_type: "string"` while its `description` is
+ * `ui_type: "long-string"` with `markdown: True` (see `ServiceMetadata.qc`).
+ * Every one of them — plus `email`, `uuid`, `hostname`, `ipv4`, `ipv6` and
+ * `phone` — rendered through the same growing textarea, so a technical name, a
+ * version and an IP address all accepted Enter.
+ *
+ * That is not a cosmetic problem. These values become YAML keys, class names,
+ * URLs and identifiers; a newline in one of them is invalid input that the form
+ * happily accepted and passed on, and the operator had no way to see it.
+ *
+ * The rule is the server's own contract, stated once here rather than guessed
+ * per field, and it is enforced in `LongString.tsx`.
+ *
+ * It lives in reqraft rather than in a consumer because the consumer is not the
+ * only renderer: qorus-ide fixed this in its OWN long-string field, and every
+ * form that goes through FormEngine — which is where an alert rule's Internal
+ * Name, Name and Short Description are — reaches THIS one instead. The fix was
+ * real and the field in front of the operator still took Enter.
+ */
+
+/**
+ * The string types that hold exactly one line — the ones routed to a textarea
+ * today.
+ *
+ * Listed explicitly rather than derived by excluding the document types,
+ * because the two directions fail very differently. Missing a single-line type
+ * here leaves it behaving as it does now — no worse. Wrongly treating a new
+ * DOCUMENT type as single-line would flatten a user's text as they typed it,
+ * which is data loss. So an unrecognised type stays multi-line.
+ */
+const SINGLE_LINE_STRING_TYPES = new Set([
+  'string',
+  'email',
+  'uuid',
+  'hostname',
+  'ipv4',
+  'ipv6',
+  'phone',
+]);
+
+/** True when a string field of this type holds a single line. */
+export const isSingleLineStringType = (type?: string): boolean =>
+  !!type && SINGLE_LINE_STRING_TYPES.has(type);
+
+/**
+ * Flattens any line break to a single space.
+ *
+ * A space rather than nothing, because the newline is usually where a word
+ * boundary was — pasting two lines into a name should read as two words, not
+ * one run-together one. CR, LF and CRLF all collapse to one space, and the
+ * result is trimmed of leading/trailing whitespace the break introduced.
+ */
+export const flattenToSingleLine = (value: string): string =>
+  value.replace(/\r\n|\r|\n/g, ' ').replace(/ {2,}/g, ' ');
+
+/** True when the value carries a line break this field should not hold. */
+export const hasLineBreak = (value: string): boolean => /\r|\n/.test(value);