@qoretechnologies/reqraft 0.10.65 → 0.10.66-pr.137.ga1983bf

package/src/components/supportTicket/meta.ts

@@ -1,206 +0,0 @@
-import { TReqoreIntent } from '@qoretechnologies/reqore/dist/constants/theme';
-import { IReqoreIconName } from '@qoretechnologies/reqore/dist/types/icons';
-
-/*
- * The single source of truth for the Qorus support-ticket presentation
- * vocabulary — how each status / priority / category / audit-action value
- * renders (label + Reqore intent + icon), plus the interface-kind icon map and
- * the small enum helpers. Shared by every Qorus surface that shows a ticket
- * (the qorus-ide customer view, the admin-portal staff queue, the Qonsole
- * renderer) so the chips read identically everywhere and can't drift apart.
- */
-
-export type TTicketStatus = 'new' | 'open' | 'awaiting_customer' | 'resolved' | 'closed';
-export type TTicketPriority = 'low' | 'normal' | 'high' | 'urgent';
-export type TTicketCategory = 'bug' | 'question' | 'billing' | 'feature' | 'other';
-export type TTicketAuditAction = 'replied' | 'noted' | 'status_changed' | 'assigned' | 'updated';
-
-/** A message author. Staff identities are masked from the customer by the backend. */
-export type TTicketMessageAuthor = 'customer' | 'staff' | 'system';
-
-/** Which side "you" sit on — decides self-alignment and audience-specific labels. */
-export type TTicketViewerRole = 'customer' | 'staff';
-
-export interface ITicketEnumMeta {
-  label: string;
-  intent: TReqoreIntent;
-  icon: IReqoreIconName;
-  /** Audience-specific label for the customer view; falls back to `label` (the
-   *  staff / neutral wording). Only a few values differ by audience. */
-  customerLabel?: string;
-}
-
-export const TICKET_STATUS_META: Record<TTicketStatus, ITicketEnumMeta> = {
-  new: { label: 'New', intent: 'info', icon: 'SparklingLine' },
-  open: { label: 'Open', intent: 'pending', icon: 'Chat3Line' },
-  awaiting_customer: {
-    label: 'Awaiting customer',
-    customerLabel: 'Awaiting your reply',
-    intent: 'warning',
-    icon: 'UserReceivedLine',
-  },
-  resolved: { label: 'Resolved', intent: 'success', icon: 'CheckLine' },
-  closed: { label: 'Closed', intent: 'muted', icon: 'CloseCircleLine' },
-};
-
-export const TICKET_PRIORITY_META: Record<TTicketPriority, ITicketEnumMeta> = {
-  low: { label: 'Low', intent: 'muted', icon: 'ArrowDownLine' },
-  normal: { label: 'Normal', intent: 'info', icon: 'SubtractLine' },
-  high: { label: 'High', intent: 'warning', icon: 'ArrowUpLine' },
-  urgent: { label: 'Urgent', intent: 'danger', icon: 'AlarmWarningLine' },
-};
-
-export const TICKET_CATEGORY_META: Record<TTicketCategory, ITicketEnumMeta> = {
-  bug: { label: 'Bug', intent: 'danger', icon: 'BugLine' },
-  question: { label: 'Question', intent: 'info', icon: 'QuestionLine' },
-  billing: { label: 'Billing', intent: 'warning', icon: 'BankCardLine' },
-  feature: { label: 'Feature request', intent: 'success', icon: 'LightbulbLine' },
-  other: { label: 'Other', intent: 'muted', icon: 'MoreLine' },
-};
-
-/** Staff-only audit trail vocabulary (used by the admin-portal staff surface).
- *  These are exactly the actions the backend writes (qorus-api
- *  `QorusSaasTicketStore::insertAudit`): a public reply, an internal note, a
- *  status change, an assignment, or `updated` (a priority/category change). */
-export const TICKET_AUDIT_ACTION_META: Record<TTicketAuditAction, ITicketEnumMeta> = {
-  replied: { label: 'Replied', intent: 'success', icon: 'ReplyLine' },
-  noted: { label: 'Internal note', intent: 'info', icon: 'StickyNoteLine' },
-  status_changed: { label: 'Status changed', intent: 'warning', icon: 'ExchangeLine' },
-  assigned: { label: 'Assigned', intent: 'pending', icon: 'UserFollowLine' },
-  updated: { label: 'Updated', intent: 'muted', icon: 'Edit2Line' },
-};
-
-/** The status label for a given viewer — the customer sees "Awaiting your reply"
- *  where staff see "Awaiting customer"; all other values are audience-neutral. */
-export const ticketStatusLabel = (
-  status: TTicketStatus,
-  viewerRole?: TTicketViewerRole
-): string => {
-  const meta = TICKET_STATUS_META[status];
-  return viewerRole === 'customer' && meta.customerLabel ? meta.customerLabel : meta.label;
-};
-
-/** A reply may be sent while a ticket is in any state except `closed`. */
-export const REPLYABLE_STATUSES: TTicketStatus[] = [
-  'new',
-  'open',
-  'awaiting_customer',
-  'resolved',
-];
-
-/** Whether a ticket can still be replied to (closed ⇒ no). */
-export const isTicketReplyable = (status: TTicketStatus): boolean => status !== 'closed';
-
-/** A file to upload with a ticket or reply — raw bytes as base64, inline on the
- *  create/reply payload (the SaaS plane has no separate multipart upload). */
-export interface IAttachmentUpload {
-  filename: string;
-  content_type: string;
-  /** base64-encoded file content */
-  content: string;
-}
-
-/** A reference to a Qorus interface on the subscriber's instance, stored as a
- *  `{kind, name}` snapshot (the interface itself lives on the instance, not the
- *  SaaS plane). Attaches to a ticket (at creation) or a message (in a reply). */
-export interface IInterfaceReference {
-  /** interface type: workflow / service / job / fsm / qog / connection / ... */
-  interface_kind: string;
-  /** interface name (may include a version) */
-  interface_name: string;
-  /** server-assigned reference UUID (present on read, absent when submitting) */
-  reference_id?: string;
-  /** For an app-triggered interface (a qog): the triggering app's name. A viewer
-   *  with the app catalogue (the customer's IDE) resolves it to the app's logo the
-   *  same way the qogs list does — see `resolveInterfaceImage` on the tags. */
-  trigger_app?: string;
-  /** A pre-resolved logo/image (data-URI or URL) for the chip, e.g. the trigger
-   *  app's logo. Travels with the reference so a viewer without the app catalogue
-   *  (staff triage, the Qonsole card) still shows it. */
-  logo?: string;
-}
-
-// Built-in per-kind icons for referenced interfaces, kept in step with the
-// qorus-ide interface vocabulary. Used when a consumer doesn't pass its own
-// `resolveInterfaceIcon`, so the staff view and the Qonsole renderer show the
-// same chips as the customer view without each re-declaring the mapping.
-const DEFAULT_INTERFACE_ICONS: Record<string, IReqoreIconName> = {
-  workflow: 'GitBranchLine',
-  service: 'ServerLine',
-  job: 'CalendarLine',
-  fsm: 'DashboardLine',
-  // qog fallback glyph (used only when there's no trigger-app logo to show)
-  qog: 'FlowChart',
-  connection: 'Plug2Line',
-  mapper: 'MindMap',
-  class: 'CodeSLine',
-  'value-map': 'BringToFront',
-  'ai-collection': 'FileMarkedLine',
-  'ai-endpoint': 'RobotLine',
-  'ai-guardrail': 'ShieldLine',
-};
-
-/** Default per-kind icon for a referenced interface, with a generic fallback. */
-export const defaultInterfaceIcon = (kind: string): IReqoreIconName =>
-  DEFAULT_INTERFACE_ICONS[kind] ?? 'CodeBoxLine';
-
-/**
- * An interface kind's mark: a font icon, and optionally an image (e.g. the green
- * Qog logo). The font icon is what shows while the image loads, and instead of it
- * when there is none or it cannot load. Same shape as qorus-ide's
- * `interfaceKindMark()`, so the IDE can return that directly.
- */
-export interface IInterfaceKindMark {
-  icon: IReqoreIconName;
-  image?: string;
-}
-
-/** What a `resolveInterfaceIcon` may return: a font icon, or a mark with an image. */
-export type TInterfaceKindIcon = IReqoreIconName | IInterfaceKindMark;
-
-/** Resolve the icon for an interface kind (see `TInterfaceKindIcon`). */
-export type TResolveInterfaceIcon = (kind: string) => TInterfaceKindIcon;
-
-/** A resolver's answer as a mark, so callers handle one shape. */
-export const toInterfaceKindMark = (icon: TInterfaceKindIcon): IInterfaceKindMark =>
-  typeof icon === 'string' ? { icon } : icon;
-
-// The reading name for each interface kind. The kind id (`value-map`, `ai-collection`)
-// is a wire value — it's what a host fetches with and what gets stored on the reference
-// — so it must never be what the user reads. These are plural because they name a
-// category the user picks from, not a single interface. `fsm` maps to "Qogs" like every
-// other user-facing surface; the id stays `fsm` wherever a host still uses it.
-const DEFAULT_INTERFACE_KIND_LABELS: Record<string, string> = {
-  workflow: 'Workflows',
-  service: 'Services',
-  job: 'Jobs',
-  fsm: 'Qogs',
-  qog: 'Qogs',
-  connection: 'Connections',
-  mapper: 'Mappers',
-  class: 'Classes',
-  'value-map': 'Value maps',
-  'ai-collection': 'AI collections',
-  'ai-endpoint': 'AI endpoints',
-  'ai-guardrail': 'AI guardrails',
-};
-
-/**
- * Default reading name for an interface kind — "Value maps" for `value-map`. An
- * unknown kind is humanised generically (separators to spaces, sentence case, a
- * plural `s`) so a kind this map hasn't caught up with still reads as a word
- * rather than an identifier. Consumers with their own vocabulary override the
- * whole thing via the picker's `resolveKindLabel`.
- */
-export const defaultInterfaceKindLabel = (kind: string): string => {
-  const known = DEFAULT_INTERFACE_KIND_LABELS[kind];
-
-  if (known) {
-    return known;
-  }
-
-  const words = kind.replace(/[-_]+/g, ' ').trim();
-  const sentenceCase = words.charAt(0).toUpperCase() + words.slice(1);
-
-  return sentenceCase.endsWith('s') ? sentenceCase : `${sentenceCase}s`;
-};

package/src/components/supportTicket/ticketModel.ts

@@ -1,131 +0,0 @@
-import type { IInterfaceReference, TTicketCategory, TTicketMessageAuthor, TTicketPriority, TTicketStatus } from './meta';
-
-/*
- * The support-ticket wire model, shared by every surface that speaks it.
- *
- * These shapes mirror the `SupportTicket` / `SupportMessage` schemas served by
- * the SaaS plane — `/qorus-saas/support/*` for the customer (qorus-api
- * `QorusSaasSupportRestClass`) and `/qorus-saas-admin/support/*` for staff
- * (`QorusSaasAdminRestHandler`). Both planes serve the SAME ticket row; the
- * staff plane simply projects more of it.
- *
- * They live here because they were previously declared twice — once in
- * qorus-ide's `views/support/types.ts` and once in admin-portal's
- * `types/supportTickets.ts` — and had already started to drift. The enum
- * vocabularies (`meta.ts`) were shared from the start; the record shapes that
- * carry them were not, which is the wrong way round: a field added to the wire
- * schema had to be remembered in two repos, and nothing failed if it wasn't.
- *
- * The split below is deliberate. `ITicket` is what BOTH planes return;
- * `IStaffTicket` is the extra projection only the admin plane serves.
- * That keeps "customer must never see the assignee" a property of the type
- * rather than a convention, while still giving one place to add a field.
- */
-
-/** Attachment metadata as embedded in a message (no content). */
-export interface ITicketAttachment {
-  attachment_id: string;
-  filename: string;
-  content_type: string;
-  size_bytes: number;
-}
-
-/**
- * Attachment metadata from the ticket-level list endpoint.
- *
- * Richer than the per-message copy: it carries the provenance the embedded
- * metadata omits — who uploaded the file, when, and which reply it came from
- * (null for a file attached when the ticket was filed). A staff uploader arrives
- * already masked by the server, so this never exposes a real staff identity.
- */
-export interface ITicketAttachmentDetail extends ITicketAttachment {
-  message_id?: string | null;
-  uploaded_by?: string;
-  uploader_type?: 'customer' | 'staff';
-  created?: string;
-}
-
-/** One message in a ticket thread. */
-export interface ITicketMessage {
-  message_id: string;
-  ticket_id: string;
-  author_type: TTicketMessageAuthor;
-  /** author identity; staff identities are masked from the customer */
-  author_id: string;
-  /** message body (markdown) */
-  body: string;
-  /** staff-only internal note — never present in the customer thread */
-  internal: boolean;
-  created: string;
-  /** files attached to this message */
-  attachments?: ITicketAttachment[];
-  /** interfaces referenced in this message, as `{kind, name}` snapshots */
-  referenced_interfaces?: IInterfaceReference[];
-}
-
-/**
- * One support ticket, in the projection BOTH planes serve.
- *
- * Staff-only fields are not optional-here-required-there; they live in
- * `IStaffTicket` so a customer surface cannot read them by accident.
- */
-export interface ITicket {
-  /** external ticket UUID, used in URLs */
-  ticket_id: string;
-  /** human-visible ticket number */
-  ticket_number: number;
-  subject: string;
-  /** initial description (markdown) */
-  description: string;
-  status: TTicketStatus;
-  priority: TTicketPriority;
-  category: TTicketCategory;
-  subscription_code: string;
-  /** account name (email) of the filer */
-  created_by: string;
-  /** parent ticket UUID, when this continues a closed ticket */
-  parent_ticket_id?: string;
-  /** first staff-reply timestamp */
-  first_response_at?: string;
-  resolved_at?: string;
-  closed_at?: string;
-  /** most-recent-message timestamp */
-  last_message_at: string;
-  created: string;
-  modified?: string;
-  /** interfaces this ticket references (ticket-level), as `{kind, name}` snapshots */
-  referenced_interfaces?: IInterfaceReference[];
-}
-
-/** The extra projection the admin plane adds on top of {@link ITicket}. */
-export interface IStaffTicket extends ITicket {
-  /** owner scope key (staff view) */
-  scope_key: string;
-  /** organization / account */
-  scope_type: string;
-  account_id: number;
-  groupid?: number;
-  /** the staff assignee */
-  assignee?: string;
-}
-
-/** The offset pagination every support list endpoint returns. */
-export interface ITicketPagedResult {
-  limit: number;
-  offset: number;
-}
-
-/**
- * A ticket-list response. Generic over the ticket projection so the staff plane
- * gets `IStaffTicket[]` without redeclaring the envelope; each plane extends this
- * with the scope fields it actually serves.
- */
-export interface ITicketListResult<T extends ITicket = ITicket> extends ITicketPagedResult {
-  tickets: T[];
-}
-
-/** A message-list response for one ticket. */
-export interface ITicketMessageListResult extends ITicketPagedResult {
-  ticket_id: string;
-  messages: ITicketMessage[];
-}

package/src/components/supportTicket/useLoadedImages.ts

@@ -1,73 +0,0 @@
-import { useEffect, useState } from 'react';
-
-/* What is known about each image URL, shared by every surface for the life of
-   the page: an image that loaded once is drawn at once the next time, and one
-   that failed is not tried again on every render. */
-const imageStatus = new Map<string, 'loaded' | 'failed'>();
-const pending = new Map<string, Promise<void>>();
-
-const loadImage = (src: string): Promise<void> => {
-  let promise = pending.get(src);
-  if (!promise) {
-    promise = new Promise<void>((resolve) => {
-      const image = new Image();
-      image.onload = () => {
-        imageStatus.set(src, 'loaded');
-        resolve();
-      };
-      image.onerror = () => {
-        imageStatus.set(src, 'failed');
-        resolve();
-      };
-      image.src = src;
-    }).finally(() => pending.delete(src));
-    pending.set(src, promise);
-  }
-  return promise;
-};
-
-/**
- * Which of `sources` have loaded. An icon that has an image draws its font icon
- * until this says the image loaded, and keeps the font icon when it fails — the
- * image is never drawn as a broken picture or an empty box.
- *
- * One hook for a whole list, so a component that maps over references (or a
- * `ReqoreMenu`, which clones its children and so cannot hold per-item hooks)
- * asks once.
- */
-export const useLoadedImages = (sources: Array<string | undefined>): ((src?: string) => boolean) => {
-  const [, setVersion] = useState(0);
-  const key = sources.filter(Boolean).join('\u0000');
-
-  useEffect(() => {
-    let active = true;
-    const unknown = Array.from(new Set(sources.filter((src): src is string => !!src))).filter(
-      (src) => !imageStatus.has(src)
-    );
-    unknown.forEach((src) => {
-      loadImage(src).then(() => {
-        if (active) {
-          setVersion((version) => version + 1);
-        }
-      });
-    });
-    return () => {
-      active = false;
-    };
-  }, [key]);
-
-  return (src?: string) => !!src && imageStatus.get(src) === 'loaded';
-};
-
-/**
- * Resolves once `src` has loaded or failed — so a test or story can check the
- * settled state instead of waiting an arbitrary time.
- */
-export const whenImageSettled = (src: string): Promise<void> =>
-  imageStatus.has(src) ? Promise.resolve() : loadImage(src);
-
-/** Forget every image's status. For tests only. */
-export const resetLoadedImagesForTests = (): void => {
-  imageStatus.clear();
-  pending.clear();
-};