@qoretechnologies/reqraft 0.10.66-pr.145.gcb1e59d → 0.10.66

package/src/components/form/fields/schema-definition/TableEditor.tsx

@@ -1,155 +0,0 @@
-/**
- * One table's expanded editor body — the bespoke surface for the locked
- * "inline expanded panel per table" decision.
- *
- * A table has no leaf fields of its own (its catalogue children are all
- * maps / groups: columns, keys, FKs, indexes, triggers), so the body is
- * a nested `ReqoreTabs` — one tab per child section — with each tab
- * delegating to the generic `CatalogNodeEditor`.
- */
-import {
-  ReqoreControlGroup,
-  ReqoreTabs,
-  ReqoreTabsContent,
-  ReqoreTag,
-} from '@qoretechnologies/reqore';
-import { memo, useMemo, useState } from 'react';
-import { partitionCatalogOptions } from './catalog';
-import { CatalogNodeEditor, RenameField } from './CatalogNodeEditor';
-import { SECTION_ICONS, sectionCount } from './helpers';
-import {
-  buildTableSectionResolver,
-  SuggestionProvider,
-  TKnownSection,
-  useSchemaDefinition,
-} from './referenceSuggestions';
-import { ICatalogOptions } from './types';
-
-const SECTIONS_WITH_SUGGESTIONS: ReadonlySet<TKnownSection> = new Set<TKnownSection>([
-  'primary_key',
-  'unique_constraints',
-  'foreign_constraints',
-  'indexes',
-]);
-
-export interface ITableEditorProps {
-  name: string;
-  tableName: string;
-  /** Rename the table — bubbles a key rename up to the Tables map. */
-  onRename: (newName: string) => void;
-  /** Returns `true` when a proposed table name collides with a sibling. */
-  taken?: (next: string) => boolean;
-  /** The per-table catalogue options (`tableOptions`). */
-  options: ICatalogOptions;
-  value: Record<string, unknown>;
-  onChange: (value: Record<string, unknown>) => void;
-  readOnly?: boolean;
-}
-
-export const TableEditor = memo(
-  ({
-    name,
-    tableName,
-    onRename,
-    taken,
-    options,
-    value,
-    onChange,
-    readOnly,
-  }: ITableEditorProps) => {
-    const sections = useMemo(
-      () => partitionCatalogOptions(options).nested,
-      [options]
-    );
-    const [activeTab, setActiveTab] = useState<string | number>(
-      sections[0]?.[0] ?? 'columns'
-    );
-
-    return (
-      <ReqoreControlGroup vertical fluid gapSize='normal'>
-        {readOnly ? (
-          <ReqoreControlGroup verticalAlign='center' gapSize='small'>
-            <ReqoreTag fixed minimal size='small' icon='Table2' label='Table' />
-            <ReqoreTag size='small' label={tableName} />
-          </ReqoreControlGroup>
-        ) : (
-          <RenameField
-            value={tableName}
-            taken={taken}
-            onRename={onRename}
-            label='Table name'
-          />
-        )}
-
-        <ReqoreTabs
-          flat
-          size='small'
-          tabsPadding='vertical'
-          activeTab={activeTab}
-          onTabChange={setActiveTab}
-          tabs={sections.map(([key, node]) => {
-            const count = node.type ? sectionCount(value?.[key]) : undefined;
-            return {
-              id: key,
-              label: node.display_name,
-              icon: SECTION_ICONS[key],
-              badge: count || undefined,
-              tooltip: node.short_desc,
-            };
-          })}
-        >
-          {sections.map(([key, node]) => {
-            const editor = (
-              <CatalogNodeEditor
-                name={`${name}-${key}`}
-                node={node}
-                value={value?.[key]}
-                onChange={(next) => onChange({ ...value, [key]: next })}
-                readOnly={readOnly}
-              />
-            );
-            return (
-              <ReqoreTabsContent key={key} tabId={key}>
-                {SECTIONS_WITH_SUGGESTIONS.has(key as TKnownSection) ? (
-                  <SectionWithSuggestions
-                    tableName={tableName}
-                    section={key as TKnownSection}
-                  >
-                    {editor}
-                  </SectionWithSuggestions>
-                ) : (
-                  editor
-                )}
-              </ReqoreTabsContent>
-            );
-          })}
-        </ReqoreTabs>
-      </ReqoreControlGroup>
-    );
-  }
-);
-
-/**
- * Wraps a table sub-section's editor with a suggestion resolver tied
- * to this table — so a primary key's `columns` list, a foreign
- * constraint's `table` / `target_columns`, and the like get
- * contextual `allowed_values` from the schema's own tree.
- */
-const SectionWithSuggestions = memo(
-  ({
-    tableName,
-    section,
-    children,
-  }: {
-    tableName: string;
-    section: TKnownSection;
-    children: React.ReactNode;
-  }) => {
-    const definition = useSchemaDefinition();
-    const resolver = useMemo(
-      () => buildTableSectionResolver(definition, tableName, section),
-      [definition, tableName, section]
-    );
-    return <SuggestionProvider resolver={resolver}>{children}</SuggestionProvider>;
-  }
-);

package/src/components/form/fields/schema-definition/TablesTab.tsx

@@ -1,138 +0,0 @@
-/**
- * The Tables tab — a stack of inline-expandable panels, one per table
- * (the locked "inline expanded panel per table" decision). Each panel
- * collapses to a one-line summary and expands in place to reveal the
- * full `TableEditor`.
- */
-import {
-  ReqoreButton,
-  ReqoreCallout,
-  ReqoreControlGroup,
-  ReqorePanel,
-  useReqoreProperty,
-} from '@qoretechnologies/reqore';
-import { memo, useCallback } from 'react';
-import { Hint } from './Hint';
-import { TableEditor } from './TableEditor';
-import { removeKey, renameKey, sectionCount, setKey, uniqueKey } from './helpers';
-import { ICatalogMap } from './types';
-
-export interface ITablesTabProps {
-  /** The `tables` map node from the catalogue. */
-  node: ICatalogMap;
-  value: Record<string, Record<string, unknown>>;
-  onChange: (value: Record<string, Record<string, unknown>>) => void;
-  readOnly?: boolean;
-}
-
-export const TablesTab = memo(
-  ({ node, value, onChange, readOnly }: ITablesTabProps) => {
-    const tables = Object.entries(value ?? {});
-    const confirmAction = useReqoreProperty('confirmAction');
-
-    const addTable = useCallback(() => {
-      onChange(setKey(value, uniqueKey(value, 'new_table'), {}));
-    }, [value, onChange]);
-
-    const confirmRemoveTable = useCallback(
-      (tableName: string) => {
-        const colCount = sectionCount(value[tableName]?.columns);
-        confirmAction({
-          title: 'Remove table',
-          description: `Remove the table "${tableName}"${
-            colCount > 0
-              ? ` and its ${colCount} column${colCount === 1 ? '' : 's'}`
-              : ''
-          }?`,
-          confirmLabel: 'Remove table',
-          intent: 'danger',
-          onConfirm: () => onChange(removeKey(value, tableName)),
-        });
-      },
-      [value, onChange, confirmAction]
-    );
-
-    if (tables.length === 0) {
-      return (
-        <ReqoreControlGroup vertical fluid gapSize='normal'>
-          <ReqoreCallout intent='info' flat icon='Table2'>
-            {readOnly
-              ? 'This schema defines no tables.'
-              : 'No tables yet. Add the first table to start building the schema.'}
-          </ReqoreCallout>
-          {!readOnly ? (
-            <ReqoreButton icon='AddLine' intent='info' minimal fixed onClick={addTable}>
-              Add table
-            </ReqoreButton>
-          ) : null}
-        </ReqoreControlGroup>
-      );
-    }
-
-    return (
-      <ReqoreControlGroup vertical fluid gapSize='small'>
-        {!readOnly ? (
-          <Hint
-            id='hint.schema-tables'
-            title='Working with tables'
-            icon='Table2'
-          >
-            Each row is a database table. Expand one to reach its
-            columns, primary key, indexes, and constraints — each on its
-            own sub-tab. <b>Click a column row to edit it in a side
-            panel</b> where you set its full definition.
-          </Hint>
-        ) : null}
-        {tables.map(([tableName, tableValue]) => {
-          const columnCount = sectionCount(tableValue?.columns);
-          return (
-            <ReqorePanel
-              key={tableName}
-              raised
-              collapsible
-              isCollapsed
-              icon='Table2'
-              label={tableName}
-              badge={[
-                `${columnCount} column${columnCount === 1 ? '' : 's'}`,
-              ]}
-              actions={
-                readOnly
-                  ? undefined
-                  : [
-                      {
-                        icon: 'DeleteBinLine',
-                        minimal: true,
-                        flat: true,
-                        intent: 'danger',
-                        size: 'small',
-                        tooltip: 'Remove table',
-                        onClick: () => confirmRemoveTable(tableName),
-                      },
-                    ]
-              }
-            >
-              <TableEditor
-                name={`table-${tableName}`}
-                tableName={tableName}
-                onRename={(next) =>
-                  onChange(renameKey(value, tableName, next))
-                }
-                taken={(next) => value[next] !== undefined}
-                options={node.options}
-                value={tableValue ?? {}}
-                onChange={(next) => onChange(setKey(value, tableName, next))}
-                readOnly={readOnly}
-              />
-            </ReqorePanel>
-          );
-        })}
-        {!readOnly ? (
-          <ReqoreButton icon='AddLine' intent='info' minimal fixed onClick={addTable}>
-            Add table
-          </ReqoreButton>
-        ) : null}
-      </ReqoreControlGroup>
-    );
-  }
-);

package/src/components/form/fields/schema-definition/catalog.ts

@@ -1,237 +0,0 @@
-/**
- * Catalogue helpers — node-kind discrimination plus the adapter that
- * turns a catalogue `options` hash into the `IOptionsSchema` the shared
- * `<Options>` field renders.
- *
- * The editor is fully server-driven: it never hard-codes a DataSchema
- * shape. Every form field comes from `GET /schemas?action=options`
- * through these helpers.
- */
-import { TQorusType } from '@qoretechnologies/ts-toolkit';
-import { IQorusAllowedValue } from '@qoretechnologies/ts-toolkit/dist/types/forms';
-import { IOptions, IOptionsSchema, TOption } from '../../engine/FormEngine';
-import {
-  ICatalogGroup,
-  ICatalogLeaf,
-  ICatalogList,
-  ICatalogMap,
-  ICatalogNode,
-  ICatalogOptions,
-} from './types';
-
-/** A catalogue node is a leaf when it carries no nested `options` tree. */
-export const isCatalogLeaf = (node: ICatalogNode): node is ICatalogLeaf =>
-  !('options' in node) || node.options === undefined;
-
-/** A group wraps nested `options` and carries no scalar `type`. */
-export const isCatalogGroup = (node: ICatalogNode): node is ICatalogGroup =>
-  !isCatalogLeaf(node) && node.type === undefined;
-
-/** A node is optional when its Qore type string is prefixed with `*`. */
-export const isOptionalType = (type?: string): boolean =>
-  typeof type === 'string' && type.startsWith('*');
-
-/** Strips the leading `*` (optional marker) from a Qore type string. */
-const bareType = (type: string): string =>
-  type.startsWith('*') ? type.slice(1) : type;
-
-/**
- * A map is `*hash<auto>` + a per-entry `options` shape. The type must
- * *start* with `hash` — a list of hashes (`*list<hash<auto>>`) also
- * contains the substring `hash`, so a prefix check is required.
- */
-export const isCatalogMap = (node: ICatalogNode): node is ICatalogMap =>
-  !isCatalogLeaf(node) &&
-  typeof node.type === 'string' &&
-  bareType(node.type).startsWith('hash');
-
-/** A list is `*list<hash<auto>>` + a per-element `options` shape. */
-export const isCatalogList = (node: ICatalogNode): node is ICatalogList =>
-  !isCatalogLeaf(node) &&
-  typeof node.type === 'string' &&
-  bareType(node.type).startsWith('list');
-
-/**
- * Maps a catalogue Qore type string to the `<Options>` field type plus
- * the element type for list fields.
- *
- * The field type is a string rather than `TQorusType` because the
- * `<Options>` / `auto` field accepts `IQorusType` — a superset that
- * includes `select-string`, which the typed `TQorusType` union omits.
- */
-export const catalogTypeToFieldType = (
-  type: string
-): { fieldType: string; elementType?: string } => {
-  const bare = bareType(type);
-  if (bare === 'select-string') {
-    return { fieldType: 'select-string' };
-  }
-  if (bare.startsWith('list<')) {
-    const inner = bare.slice('list<'.length, -1);
-    return {
-      fieldType: 'list',
-      elementType: inner === 'string' ? 'string' : 'auto',
-    };
-  }
-  if (bare.startsWith('hash')) {
-    return { fieldType: 'hash' };
-  }
-  switch (bare) {
-    case 'string':
-      return { fieldType: 'string' };
-    case 'int':
-      return { fieldType: 'int' };
-    case 'float':
-      return { fieldType: 'float' };
-    case 'number':
-      return { fieldType: 'number' };
-    case 'bool':
-      return { fieldType: 'bool' };
-    case 'date':
-      return { fieldType: 'date' };
-    default:
-      // `*auto`, `auto`, and anything unrecognised fall back to the
-      // free-form `auto` field so no catalogue value is ever undroppable.
-      return { fieldType: 'auto' };
-  }
-};
-
-/** Converts catalogue `{value, display_name}` entries to `<Options>` allowed values. */
-const toAllowedValues = (
-  leaf: ICatalogLeaf
-): IQorusAllowedValue[] | undefined => {
-  if (!leaf.allowed_values || leaf.allowed_values.length === 0) {
-    return undefined;
-  }
-  return leaf.allowed_values.map((av) => ({
-    display_name: av.display_name,
-    value: { type: 'string' as TQorusType, value: av.value },
-  }));
-};
-
-/**
- * Converts a single catalogue leaf to a `<Options>` field schema. Group
- * / map / list nodes are not form fields and must not be passed here.
- *
- * The cast bridges `select-string` (an `IQorusType` the `auto` field
- * renders) past the narrower `TQorusType` the schema object is typed
- * with.
- */
-export const catalogLeafToFieldSchema = (
-  leaf: ICatalogLeaf
-): IOptionsSchema[string] => {
-  const { fieldType, elementType } = catalogTypeToFieldType(leaf.type);
-  const allowedValues = toAllowedValues(leaf);
-  return {
-    type: fieldType,
-    ui_type: fieldType,
-    display_name: leaf.display_name,
-    short_desc: leaf.short_desc,
-    desc: leaf.desc,
-    required: !!leaf.required && !isOptionalType(leaf.type),
-    ...(elementType ? { element_type: elementType } : {}),
-    ...(allowedValues ? { allowed_values: allowedValues } : {}),
-  } as unknown as IOptionsSchema[string];
-};
-
-/**
- * Builds a new map / list entry pre-seeded with sensible defaults so
- * it does not open in an invalid state — every required enum leaf is
- * set to its first allowed value (a new column defaults to the first
- * column type, a new migration step to the first action, …).
- */
-export const seedNewEntry = (
-  options: ICatalogOptions
-): Record<string, unknown> => {
-  const seed: Record<string, unknown> = {};
-  Object.entries(options).forEach(([key, node]) => {
-    if (
-      isCatalogLeaf(node) &&
-      node.required &&
-      node.allowed_values &&
-      node.allowed_values.length > 0
-    ) {
-      seed[key] = node.allowed_values[0].value;
-    }
-  });
-  return seed;
-};
-
-/**
- * Splits a catalogue `options` hash into its leaf fields (rendered as
- * one `<Options>` form) and its nested group / map / list children
- * (each rendered by its own recursive editor).
- */
-export const partitionCatalogOptions = (options: ICatalogOptions) => {
-  const leaves: ICatalogOptions = {};
-  const nested: Array<[string, ICatalogNode]> = [];
-  Object.entries(options).forEach(([key, node]) => {
-    if (isCatalogLeaf(node)) {
-      leaves[key] = node;
-    } else {
-      nested.push([key, node]);
-    }
-  });
-  return { leaves, nested };
-};
-
-/** Builds the `<Options>` schema for the leaf subset of a catalogue hash. */
-export const leavesToOptionsSchema = (
-  leaves: ICatalogOptions
-): IOptionsSchema => {
-  const schema: IOptionsSchema = {};
-  Object.entries(leaves).forEach(([key, node]) => {
-    if (isCatalogLeaf(node)) {
-      schema[key] = catalogLeafToFieldSchema(node);
-    }
-  });
-  return schema;
-};
-
-/**
- * Wraps a plain definition hash into the `{type, value}` form
- * `<Options>` expects, keyed only by the leaf fields in `schema`.
- */
-export const hashToOptionsValue = (
-  hash: Record<string, unknown> | undefined,
-  schema: IOptionsSchema
-): IOptions => {
-  const value: IOptions = {};
-  Object.entries(schema).forEach(([key, field]) => {
-    if (hash && hash[key] !== undefined) {
-      let raw = hash[key];
-      // The `<Options>` list field expects elements wrapped as
-      // `{value, type}` — a bare `['a','b']` renders as empty rows.
-      if (field.type === 'list' && Array.isArray(raw)) {
-        const elementType =
-          (field as { element_type?: string }).element_type ?? 'string';
-        raw = raw.map((el) => ({ value: el, type: elementType }));
-      }
-      value[key] = {
-        type: field.type as TQorusType,
-        value: raw,
-      } as TOption;
-    }
-  });
-  return value;
-};
-
-/**
- * Inverse of {@link hashToOptionsValue}'s list wrapping — flattens a
- * `<Options>` list value (`[{value, type}]`) back to the bare array
- * (`['a', 'b']`) the DataSchema definition stores.
- */
-export const unwrapListValues = (
-  flat: Record<string, unknown>,
-  schema: IOptionsSchema
-): void => {
-  Object.entries(schema).forEach(([key, field]) => {
-    if (field.type === 'list' && Array.isArray(flat[key])) {
-      flat[key] = (flat[key] as unknown[]).map((el) =>
-        el && typeof el === 'object' && 'value' in el
-          ? (el as { value: unknown }).value
-          : el
-      );
-    }
-  });
-};

package/src/components/form/fields/schema-definition/helpers.ts

@@ -1,90 +0,0 @@
-/**
- * Small pure helpers shared across the schema-definition editor —
- * immutable hash/list mutations and display formatting. No React here.
- */
-import { IReqoreIconName } from '@qoretechnologies/reqore/dist/types/icons';
-
-/** Immutably sets a key on a hash, preserving insertion order. */
-export const setKey = <T>(
-  hash: Record<string, T> | undefined,
-  key: string,
-  value: T
-): Record<string, T> => ({ ...(hash ?? {}), [key]: value });
-
-/** Immutably removes a key from a hash. */
-export const removeKey = <T>(
-  hash: Record<string, T> | undefined,
-  key: string
-): Record<string, T> => {
-  const next = { ...(hash ?? {}) };
-  delete next[key];
-  return next;
-};
-
-/**
- * Immutably renames a hash key while preserving the position of every
- * entry — important so a rename doesn't reorder a table's column list.
- */
-export const renameKey = <T>(
-  hash: Record<string, T> | undefined,
-  oldKey: string,
-  newKey: string
-): Record<string, T> => {
-  if (!hash || oldKey === newKey) return { ...(hash ?? {}) };
-  const next: Record<string, T> = {};
-  Object.entries(hash).forEach(([k, v]) => {
-    next[k === oldKey ? newKey : k] = v;
-  });
-  return next;
-};
-
-/**
- * Picks a unique key for a new map entry — `base`, then `base_2`,
- * `base_3`, … — so "Add" never silently overwrites an existing entry.
- */
-export const uniqueKey = (
-  hash: Record<string, unknown> | undefined,
-  base: string
-): string => {
-  if (!hash || hash[base] === undefined) return base;
-  let n = 2;
-  while (hash[`${base}_${n}`] !== undefined) n += 1;
-  return `${base}_${n}`;
-};
-
-/** Tab / section icon for a definition section key. */
-export const SECTION_ICONS: Record<string, IReqoreIconName> = {
-  schema: 'InformationLine',
-  tables: 'Table2',
-  sequences: 'SortNumberAsc',
-  reference_data: 'SeedlingLine',
-  reference: 'SeedlingLine',
-  migrations: 'GitBranchLine',
-  advanced: 'Settings3Line',
-  columns: 'LayoutColumnLine',
-  indexes: 'SearchLine',
-  constraints: 'LinksLine',
-  auto_triggers: 'FlashlightLine',
-  triggers: 'FlashlightLine',
-  primary_key: 'Key2Line',
-  unique_constraints: 'Fingerprint2Line',
-  foreign_constraints: 'LinksLine',
-  pre_align: 'ArrowGoBackLine',
-  post_align: 'ArrowGoForwardLine',
-  reference_rows: 'SeedlingLine',
-};
-
-/** Formats an arbitrary definition value for the read-only viewer. */
-export const formatValue = (value: unknown): string => {
-  if (value === null || value === undefined) return '—';
-  if (typeof value === 'string') return value;
-  if (typeof value === 'number' || typeof value === 'boolean') {
-    return String(value);
-  }
-  if (Array.isArray(value)) return value.map(formatValue).join(', ');
-  return JSON.stringify(value);
-};
-
-/** Count of entries in a hash section (0 when absent). */
-export const sectionCount = (hash: unknown): number =>
-  hash && typeof hash === 'object' ? Object.keys(hash).length : 0;