@qoretechnologies/reqraft 0.10.64 → 0.10.65-pr.137.g62fcecc

package/src/helpers/optionUiTypes.ts

@@ -1,199 +0,0 @@
-/**
- * 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);
-
-/** The spellings that mean "no concrete type" wherever they appear. */
-export const UNTYPED_OPTION_TYPES = ['any', 'auto'] as const;
-
-export type TUntypedOptionType = (typeof UNTYPED_OPTION_TYPES)[number];
-
-const untypedOptionTypeSet = new Set<string>(UNTYPED_OPTION_TYPES);
-
-/**
- * `auto` and `any` declare no type: they say the AUTHOR chooses one, and the
- * chosen type is recorded beside the value, not in the schema. A reader that
- * takes the schema's word therefore learns nothing about what the value has to
- * look like — `validateField` handles these two by auto-detecting from the
- * value, which accepts whatever is there.
- *
- * This list lives here, with the rest of the type vocabulary, rather than in
- * `engine/typeChoices` where it started: a helper cannot import from a
- * component, and the rule was already spelled out by hand in seven other
- * places.
- */
-export const isUntypedOptionType = (type: unknown): type is TUntypedOptionType =>
-  typeof type === 'string' && untypedOptionTypeSet.has(type);
-
-/**
- * The type a declaration is READ as when it names several.
- *
- * A data provider option that accepts more than one type is served with them as
- * a list (`DataProvider::getInfoAsData()`), and the form renders such an option
- * as the first of them (`FormEngine`'s `getType`). Every other reader of a
- * declared type has to answer from the same entry, or the row is rendered as
- * one type and judged as another — the rule was spelled out by hand in four
- * places, each slightly differently, and the odd one out silently answered
- * "no type at all" for every multi-type option.
- */
-export const firstDeclaredType = (type: unknown): string | undefined => {
-  const declared = Array.isArray(type) ? type[0] : type;
-  return typeof declared === 'string' ? declared : undefined;
-};

package/src/helpers/options.ts

@@ -1,150 +0,0 @@
-import { IQorusFormSchema, TQorusFormFieldSchema } from '@qoretechnologies/ts-toolkit';
-
-export const getOptionsFromRequiredGroups = (
-  schema: IQorusFormSchema,
-  groups: string[],
-  currentOption?: string
-): string[] => {
-  return Object.keys(schema)
-    .filter((option) => {
-      return (schema[option] as TQorusFormFieldSchema).required_groups?.some((group) =>
-        groups.includes(group)
-      );
-    })
-    .filter((option) => option !== currentOption);
-};
-
-export const getRequiredOptionMessage = (
-  schema: IQorusFormSchema,
-  groups: string[],
-  currentField: string
-): string => {
-  if ((schema[currentField] as TQorusFormFieldSchema).required) {
-    return 'This field is required';
-  }
-
-  const requiredOptions = getOptionsFromRequiredGroups(schema, groups, currentField)
-    .map((option) => (schema[option] as TQorusFormFieldSchema).display_name)
-    .join(' or ');
-
-  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;
-
-/**
- * The schema with every one-of group that offers no choice turned back into a
- * plain required field.
- *
- * A `required_groups` group says *"at least one of these"*, and the whole
- * affordance built on it — the ONE OF header, the `Covers` / `Covered by “X”`
- * chips, the *"this field or X is required"* message — exists to tell an author
- * that they have a CHOICE and which way they have answered it. When the group
- * has a single member in the schema in hand, there is no choice: that field
- * must be set, which is exactly what `required` already means. Saying it in the
- * one-of grammar instead is worse than saying nothing, because a green tick
- * beside a value reads as confirmation of the VALUE — a Qorus test author read
- * `✓ COVERS` beside their service as "yes, this is the service your test is
- * about", which the form never said and cannot know.
- *
- * This is not a hypothetical: a server may legitimately declare a group over an
- * API-only alternative it then hides from the form (Qorus test steps put
- * `target` in a group with `service`, and hide `target`), so the form is handed
- * one member of a two-member group. The group is still real for the API and
- * must stay in the schema the server serves; it is only this form that has
- * nothing to offer.
- *
- * The rewrite is exact rather than cosmetic: a one-of over one option and a
- * required option are the same constraint, so validation, the completion meter
- * and the required-only filter all keep saying what they said — in the grammar
- * that fits.
- *
- * A field in a degenerate group is required by that group ALONE, so it is
- * marked required even when it also belongs to a group that does offer a
- * choice; that other group keeps its affordance and is satisfied by this field
- * either way. The key is deleted rather than emptied because `[]` is truthy,
- * and every consumer tests `option.required_groups` for existence.
- *
- * Returns the schema unchanged — the same object — when no group degenerates,
- * so it can sit on a memo without giving every render a new schema identity.
- */
-export const resolveDegenerateRequiredGroups = <T extends IQorusFormSchema | undefined>(
-  schema: T
-): T => {
-  if (!schema) return schema;
-
-  const membersPerGroup: Record<string, number> = {};
-  Object.values(schema).forEach((option) => {
-    (option as TQorusFormFieldSchema)?.required_groups?.forEach((group) => {
-      membersPerGroup[group] = (membersPerGroup[group] ?? 0) + 1;
-    });
-  });
-
-  const degenerate = (group: string): boolean => membersPerGroup[group] < 2;
-  if (!Object.keys(membersPerGroup).some(degenerate)) return schema;
-
-  const resolved: IQorusFormSchema = {};
-  Object.entries(schema).forEach(([name, option]) => {
-    const groups = (option as TQorusFormFieldSchema)?.required_groups;
-    if (!groups?.some(degenerate)) {
-      resolved[name] = option;
-      return;
-    }
-    const kept = groups.filter((group) => !degenerate(group));
-    const rest = { ...(option as TQorusFormFieldSchema) };
-    delete rest.required_groups;
-    resolved[name] = {
-      ...rest,
-      required: true,
-      ...(kept.length ? { required_groups: kept } : {}),
-    } as TQorusFormFieldSchema;
-  });
-  return resolved as T;
-};
-
-/** A note attached to a field or to one of its allowed values. */
-export interface ISchemaMessage {
-  intent?: string;
-  title?: string;
-  content?: string;
-}
-
-/** The sentence a refusal with no reason of its own falls back to. */
-export const UNAVAILABLE_VALUE_FALLBACK_REASON = 'This value is not available';
-
-/**
- * Which of a refused value's messages is the REASON it was refused.
- *
- * A value can carry several notes, and only one of them explains why it cannot
- * be picked. The most serious one does: a `danger` message is what a refusal
- * sounds like, a `warning` is the next thing to it, and an `info` note beside
- * either is a remark about the value rather than about the refusal.
- *
- * Both the form's resolver and the picker that renders a pre-resolved refusal
- * ask this, so the two cannot disagree about which words stand in for a choice.
- */
-export const getRefusalMessage = <T extends ISchemaMessage>(messages?: T[]): T | undefined =>
-  messages?.find((message) => message.intent === 'danger') ||
-  messages?.find((message) => message.intent === 'warning') ||
-  messages?.[0];

package/src/helpers/providerValue.ts

@@ -1,125 +0,0 @@
-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/scrollbar.ts

@@ -1,32 +0,0 @@
-import { css } from 'styled-components';
-
-/*
- * The thin, unobtrusive scrollbar the Qorus surfaces use — a transparent track and a
- * translucent rounded thumb — in place of the platform default, which reads as heavy
- * chrome inside a dark panel. Drop it into any `styled` scroll container:
- *
- *   const Scroll = styled.div`
- *     overflow-y: auto;
- *     ${thinScrollbar}
- *   `;
- *
- * webkit-only on purpose: setting `scrollbar-width` as well lets Chromium override this
- * custom 6px with its own wider "thin", so the two disagree. Firefox keeps its native
- * bar, which is already slim.
- */
-export const thinScrollbar = css`
-  &::-webkit-scrollbar {
-    width: 6px;
-    height: 6px;
-  }
-  &::-webkit-scrollbar-track {
-    background: transparent;
-  }
-  &::-webkit-scrollbar-thumb {
-    background: rgba(255, 255, 255, 0.15);
-    border-radius: 3px;
-  }
-  &::-webkit-scrollbar-thumb:hover {
-    background: rgba(255, 255, 255, 0.28);
-  }
-`;

package/src/helpers/singleLineString.ts

@@ -1,61 +0,0 @@
-/**
- * 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);

package/src/helpers/templateItems.ts

@@ -1,81 +0,0 @@
-import type { TMarkdownRenderer } from '../components/Description/markdownRendererContext';
-
-/**
- * What a template picker should actually list.
- *
- * Pickers group templates by category, which is what makes a long catalogue
- * scannable. A LONE category buys nothing and costs a click: the author opens
- * the picker, sees one row naming the category, clicks it, and only then sees
- * the values — with a back arrow as the only other thing on offer. So a single
- * category is opened for them.
- *
- * Two or more categories keep the grouping, because there the headers are doing
- * real work. This only ever removes a step that could not have gone any other
- * way.
- *
- * Lives here rather than beside either picker: `TemplateField` renders the
- * "Select Template" dropdown and `RichText` renders the in-editor `$` list, and
- * `TemplateField` already imports `RichText` — so a shared home is the only one
- * that does not close an import cycle.
- */
-export const templateItemsToShow = <T,>(items: T[] | undefined): T[] | undefined => {
-  if (items?.length !== 1) {
-    return items;
-  }
-  const only = items[0] as { items?: unknown[] };
-  return Array.isArray(only.items) && only.items.length ? (only.items as T[]) : items;
-};
-
-/**
- * A picker row's description, DRAWN.
- *
- * A description is prose, and a host that writes prose writes markdown: the
- * same author, in the same dialect, as the field descriptions and schema
- * messages this package already draws through the host's renderer. Left as a
- * string, a row explaining that a step needs a **Fixture Output** printed the
- * asterisks at the reader.
- *
- * WHERE THIS MAY BE CALLED, and why it is not simply done at the source: the
- * template list is a memo KEY in several places — `TemplateField` stringifies
- * both the incoming `templates` and the resolved `filteredTemplates`, and the
- * list is handed down to nested fields that stringify it again. `JSON.stringify`
- * throws on a React element's circular `_owner`, so an element anywhere in the
- * list takes the whole form down to a blank panel.
- *
- * So this runs at the LAST hop only — the call that hands items to a Reqore
- * control, after every key has been computed — and its result is never passed
- * on to anything that might stringify it. Reqore itself does not: it draws the
- * description into a `ReqoreTextEffect` and styled-components filters the prop
- * off the DOM.
- *
- * Without a host renderer the items are returned untouched, so a host that has
- * no markdown keeps exactly what it had.
- */
-export const renderTemplateItemDescriptions = <T,>(
-  items: T[] | undefined,
-  render: TMarkdownRenderer | undefined
-): T[] | undefined => {
-  if (!render || !items?.length) {
-    return items;
-  }
-
-  return items.map((item) => {
-    const entry = item as { description?: unknown; items?: unknown };
-    const next = { ...entry } as Record<string, unknown>;
-
-    if (typeof entry.description === 'string' && entry.description.trim()) {
-      /* `compact`, for the reason the context gives: a row is a constrained
-         container, and markdown authored as a document opens with a heading
-         that would outgrow the label above it. */
-      next.description = render({ value: entry.description, compact: true });
-    }
-
-    // Only when the item HAS children — writing the key unconditionally would
-    // give every leaf an `items` a picker could read as an empty submenu.
-    if (Array.isArray(entry.items)) {
-      next.items = renderTemplateItemDescriptions(entry.items, render);
-    }
-
-    return next as T;
-  });
-};