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

package/src/index.tsx

@@ -1,86 +0,0 @@
-export * from './components/form';
-export * from './components/log/Log';
-export {
-  validateField,
-  validateFieldWithResult,
-  isValueSet,
-  getTypeFromValue,
-  maybeParseYaml,
-  hasAllDependenciesFullfilled,
-  parseDependency,
-  validateOptionWithRequiredGroups,
-  unsatisfiedRequiredGroups,
-} from './helpers/validations';
-export type { IValidationResult } from './helpers/validations';
-export { thinScrollbar } from './helpers/scrollbar';
-export * from './components/imageLightbox';
-export { ReqraftMenu } from './components/menu/Menu';
-export type {
-  IReqraftMenuItem,
-  IReqraftMenuProps,
-  TReqraftMenu,
-  TReqraftMenuItem,
-} from './components/menu/Menu';
-
-export { useFetch } from './hooks/useFetch/useFetch';
-export type { IReqraftUseFetch } from './hooks/useFetch/useFetch';
-export { useReqraftStorage } from './hooks/useStorage/useStorage';
-export type { TReqraftUseStorage } from './hooks/useStorage/useStorage';
-export * from './hooks/useWebSocket/useWebSocket';
-export {
-  initializeReqraft,
-  ReqraftProvider,
-  ReqraftQueryClient,
-} from './providers/ReqraftProvider';
-export { currentUserStore as ReqraftCurrentUserStore } from './stores/currentUser/currentUser';
-export type {
-  ICurrentUser,
-  ICurrentUserStore,
-} from './stores/currentUser/currentUser';
-export {
-  fetchConfig,
-  isQueryCancelled,
-  query,
-  queryRaw,
-  reqraftApiPath,
-  reqraftCacheKey,
-  setupFetch,
-} from './utils/fetch';
-export type {
-  IReqraftFetchConfig,
-  IReqraftFetchResponse,
-  IReqraftQueryConfig,
-  IReqraftRawResponse,
-} from './utils/fetch';
-export * from './utils/websocket';
-export { ReqraftLspClient } from './utils/lspClient';
-export type { IReqraftLspClientOptions } from './utils/lspClient';
-export type {
-  ILspCompletionItem,
-  ILspDiagnostic,
-  ILspMarkupContent,
-  ILspParameterInformation,
-  ILspPosition,
-  ILspRange,
-  ILspSemanticToken,
-  ILspSemanticTokensLegend,
-  ILspServerCapabilities,
-  ILspSignatureHelp,
-  ILspSignatureInformation,
-  ILspTextEdit,
-  TLspDocumentText,
-} from './utils/lspClient.types';
-export * from './components/composer';
-export * from './components/smartEditor';
-export * from './components/dpqlEditor';
-export * from './components/qonsoleSmartInput';
-export * from './components/supportTicket';
-export * from './components/ticketThread';
-export * from './components/ticketReferences';
-export * from './components/searchFilterBar';
-export * from './components/codeSize';
-// First-party tracking, consent and A/B testing (design/TRACKING.md). Also importable
-// on its own, without the rest of Reqraft: `@qoretechnologies/reqraft/dist/tracking`
-// (the engine, React only) and `@qoretechnologies/reqraft/dist/tracking/ui` (the A/B test UI).
-export * from './tracking';
-export * from './tracking/ui';

package/src/providers/FetchProvider.tsx

@@ -1,40 +0,0 @@
-import { useQueryClient } from '@tanstack/react-query';
-import { FetchContext, TReqraftContextQueryConfig } from '../contexts/FetchContext';
-import { query } from '../utils/fetch';
-
-export interface IReqraftFetchProviderProps {
-  children: React.ReactNode;
-}
-
-export const ReqraftFetchProvider = ({ children }: IReqraftFetchProviderProps) => {
-  const queryClient = useQueryClient();
-
-  async function get<T>(config: TReqraftContextQueryConfig) {
-    return query<T>({ queryClient, ...config, method: 'GET' });
-  }
-
-  async function post<T>(config: TReqraftContextQueryConfig) {
-    return query<T>({ queryClient, ...config, method: 'POST' });
-  }
-
-  async function put<T>(config: TReqraftContextQueryConfig) {
-    return query<T>({ queryClient, ...config, method: 'PUT' });
-  }
-
-  async function del<T>(config: TReqraftContextQueryConfig) {
-    return query<T>({ queryClient, ...config, method: 'DELETE' });
-  }
-
-  return (
-    <FetchContext.Provider
-      value={{
-        get,
-        post,
-        put,
-        del,
-      }}
-    >
-      {children}
-    </FetchContext.Provider>
-  );
-};

package/src/providers/ReqraftProvider.tsx

@@ -1,52 +0,0 @@
-import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
-import { ReactNode } from 'react';
-import { IReqraftContext, ReqraftContext } from '../contexts/ReqraftContext';
-import { IReqraftFetchConfig, setupFetch } from '../utils/fetch';
-import { ReqraftFetchProvider } from './FetchProvider';
-import { ReqraftUserProvider } from './StorageProvider';
-
-export const ReqraftQueryClient = new QueryClient();
-
-export interface IReqraftProviderProps extends IReqraftContext {
-  children: ReactNode;
-  reactQueryClient?: QueryClient;
-  /*
-   * If true, the component will wait for the storage to be loaded before rendering the children.
-   */
-  waitForStorage?: boolean;
-}
-
-export interface IReqraftOptions {
-  instance?: string;
-  instanceToken?: string;
-  instanceRbacDisabled?: boolean;
-  instanceUnauthorizedRedirect?: IReqraftFetchConfig['unauthorizedRedirect'];
-}
-
-export const initializeReqraft = (options: IReqraftOptions) => {
-  setupFetch({
-    instance: options.instance,
-    instanceToken: options.instanceToken,
-    instanceRbacDisabled: options.instanceRbacDisabled,
-    unauthorizedRedirect: options.instanceUnauthorizedRedirect,
-  });
-
-  return ReqraftProvider;
-};
-
-export const ReqraftProvider = ({
-  appName,
-  children,
-  reactQueryClient,
-  waitForStorage = true,
-}: IReqraftProviderProps) => {
-  return (
-    <ReqraftContext.Provider value={{ appName }}>
-      <QueryClientProvider client={reactQueryClient || ReqraftQueryClient}>
-        <ReqraftFetchProvider>
-          <ReqraftUserProvider waitForStorage={waitForStorage}>{children}</ReqraftUserProvider>
-        </ReqraftFetchProvider>
-      </QueryClientProvider>
-    </ReqraftContext.Provider>
-  );
-};

package/src/providers/StorageProvider.tsx

@@ -1,131 +0,0 @@
-import { cloneDeep, get, set } from 'lodash';
-import { ReactNode, useCallback, useMemo } from 'react';
-import { useEffectOnce } from 'react-use';
-import type { Get } from 'type-fest';
-import { ReqraftStorageContext, TReqraftStorage } from '../contexts/StorageContext';
-import { useFetch } from '../hooks/useFetch/useFetch';
-import { useReqraftProperty } from '../hooks/useReqraftProperty';
-import { TReqraftStorageValue } from '../hooks/useStorage/useStorage';
-import { currentUserStore } from '../stores/currentUser/currentUser';
-import { isQueryCancelled } from '../utils/fetch';
-import { IReqraftProviderProps } from './ReqraftProvider';
-
-/**
- * Apply a single path write onto the current storage blob, seeding a fresh object
- * when the user has no storage yet.
- *
- * `?? {}` is load-bearing: a user who has never written storage has
- * `storage === undefined | null`, and `set(cloneDeep(undefined), …)` returns
- * `undefined` (lodash won't set on a nullish target). Without the seed the FIRST
- * write for such a user — e.g. accepting the cookie-consent banner — persists an
- * empty body and silently drops the value, so the flag stays unset forever and
- * the banner never closes. Exported for testing.
- */
-export const applyStorageWrite = (
-  storage: TReqraftStorage | undefined,
-  path: string,
-  value: unknown
-): TReqraftStorage => set(cloneDeep(storage) ?? {}, path, value);
-
-export interface IReqraftStorageProviderProps
-  extends Pick<IReqraftProviderProps, 'waitForStorage'> {
-  children: ReactNode;
-}
-
-export const ReqraftUserProvider = ({ children, waitForStorage }: IReqraftStorageProviderProps) => {
-  const appName = useReqraftProperty('appName');
-  const {
-    currentUser,
-    updateStorage: updateCurrentUserStorage,
-    load: loadCurrentUser,
-    loading,
-  } = currentUserStore();
-
-  useEffectOnce(() => {
-    /* A user that cannot be loaded - no token (401), another origin the instance
-       refuses (CORS), no such endpoint (404) - is a state the store keeps
-       (`error`, `errorData`), and the page renders without one. The promise was
-       dropped, so the failure was an unhandled rejection: Storybook marked a story
-       wrapped in this provider as errored whenever it landed first.
-       A request that was abandoned (the query cache was cleared while it was in
-       flight - a story runner does it between stories) is not one of those: the
-       server refused nothing, so there is nothing to warn about. */
-    loadCurrentUser().catch((error: unknown) => {
-      if (isQueryCancelled(error)) {
-        return;
-      }
-
-      console.warn('Reqraft: the current user could not be loaded', error);
-    });
-  });
-
-  const { load } = useFetch({
-    url: 'users/_current_/',
-    method: 'PUT',
-    cache: false,
-  });
-
-  const getStorage = useCallback(
-    function <T extends TReqraftStorageValue>(
-      path: string,
-      defaultValue: T,
-      includeAppPrefix: boolean = true
-    ): Get<TReqraftStorage, string> {
-      const _path = includeAppPrefix ? `${appName}.${path}` : path;
-
-      return get(currentUser?.storage, _path) ?? defaultValue;
-    },
-    [appName, currentUser?.storage]
-  );
-
-  const updateStorage = useCallback(
-    function <T extends TReqraftStorageValue>(
-      path: string,
-      value: T,
-      includeAppPrefix: boolean = true
-    ) {
-      const _path = includeAppPrefix ? `${appName}.${path}` : path;
-      // Base the write on the LATEST storage read straight from the store, not
-      // the blob captured in this callback's closure. A caller holding a stale
-      // updater — e.g. an imperative store subscription created on mount, before
-      // other keys had loaded — would otherwise persist an out-of-date blob and
-      // wipe every key written to storage since its closure was captured.
-      const latestStorage = currentUserStore.getState().currentUser?.storage;
-      const updatedStorage = applyStorageWrite(latestStorage, _path, value);
-
-      updateCurrentUserStorage(updatedStorage);
-
-      load({ body: { storage: updatedStorage } });
-    },
-    [appName, load, updateCurrentUserStorage]
-  );
-
-  const removeStorageValue = useCallback(
-    function (path: string, includeAppPrefix: boolean = true) {
-      const _path = includeAppPrefix ? `${appName}.${path}` : path;
-
-      // Same as `updateStorage`: mutate the LATEST blob (never a stale closure
-      // copy), seeding a fresh object when there's no storage yet.
-      const latestStorage = currentUserStore.getState().currentUser?.storage;
-      const updatedStorage = applyStorageWrite(latestStorage, _path, null);
-
-      updateCurrentUserStorage(updatedStorage);
-
-      load({ body: { storage_path: _path } });
-    },
-    [appName, load, updateCurrentUserStorage]
-  );
-
-  const contextValue = useMemo(
-    () => ({ storage: currentUser?.storage, getStorage, updateStorage, removeStorageValue }),
-    [currentUser?.storage, getStorage, updateStorage, removeStorageValue]
-  );
-
-  if (loading && waitForStorage) {
-    return null;
-  }
-
-  return (
-    <ReqraftStorageContext.Provider value={contextValue}>{children}</ReqraftStorageContext.Provider>
-  );
-};

package/src/stores/currentUser/currentUser.stories.tsx

@@ -1,100 +0,0 @@
-import { ReqoreP, ReqoreSpinner, ReqoreTree } from '@qoretechnologies/reqore';
-import { StoryObj } from '@storybook/react-vite';
-import { testsWaitForText } from '../../../__tests__/utils';
-import { storyApiUrl } from '../../stories/storyNetwork';
-import { StoryMeta } from '../../types';
-import { currentUserStore } from './currentUser';
-
-const meta = {
-  title: 'Stores/Current User',
-  parameters: {
-    mockData: [
-      {
-        url: storyApiUrl('users?action=current'),
-        method: 'GET',
-        status: 200,
-        response: {
-          provider: 'local',
-          username: 'david',
-          name: 'David Nichols',
-          has_default: true,
-          roles: ['admin'],
-          permissions: ['USER-CONTROL'],
-          workflows: [],
-          services: [],
-          jobs: [],
-          mappers: [],
-          vmaps: [],
-          groups: [],
-          fsms: [],
-        },
-      },
-    ],
-  },
-  beforeEach: () => {
-    currentUserStore.setState({
-      currentUser: undefined,
-      loading: false,
-      error: undefined,
-      errorData: undefined,
-    });
-  },
-  render: () => {
-    const { load, loading, currentUser = {}, errorData } = currentUserStore();
-
-    return loading ? (
-      <ReqoreSpinner />
-    ) : (
-      <>
-        <ReqoreTree
-          data={errorData || currentUser}
-          bottomActions={[{ label: 'Refetch', onClick: load }]}
-        />
-      </>
-    );
-  },
-} as StoryMeta<any>;
-
-export default meta;
-export type Story = StoryObj<typeof meta>;
-
-export const CurrentUserCanBeLoaded: Story = {
-  parameters: {
-    docs: {
-      description: {
-        story:
-          'Renders a demo that reads currentUserStore — the store loads /users?action=current and the returned user object is displayed as a tree.',
-      },
-    },
-  },
-  play: async () => {
-    await testsWaitForText('"David Nichols"');
-  },
-};
-
-export const CurrentUserHasPermissions: Story = {
-  ...CurrentUserCanBeLoaded,
-  parameters: {
-    ...CurrentUserCanBeLoaded.parameters,
-    docs: {
-      description: {
-        story:
-          'Renders a demo that calls currentUserStore().hasAnyPermission — the affirmative message renders because the loaded user carries at least one of the requested permissions.',
-      },
-    },
-  },
-  render: () => {
-    const { hasAnyPermission } = currentUserStore();
-
-    return (
-      <ReqoreP>
-        {hasAnyPermission(['USER-CONTROL', 'RANDOM-PERM'])
-          ? 'Yes, user has "SERVER-CONTROL" permission'
-          : 'No'}
-      </ReqoreP>
-    );
-  },
-  play: async () => {
-    await testsWaitForText('Yes, user has "SERVER-CONTROL" permission');
-  },
-};

package/src/stores/currentUser/currentUser.tsx

@@ -1,94 +0,0 @@
-import { create } from 'zustand';
-import { IReqraftFetchResponse, isQueryCancelled, query } from '../../utils/fetch';
-
-export interface ICurrentUser {
-  provider: string;
-  username: string;
-  name: string;
-  has_default: boolean;
-  roles: string[];
-  permissions: string[];
-  workflows: string[];
-  services: string[];
-  jobs: string[];
-  mappers: string[];
-  vmaps: string[];
-  groups: string[];
-  fsms: string[];
-  oauth2_clients?: Record<string, any>[];
-  storage?: Record<string, any>;
-  sandboxed?: boolean;
-  default_group?: string;
-}
-
-export interface ICurrentUserStore {
-  currentUser?: ICurrentUser;
-  load: () => Promise<ICurrentUser>;
-  loading?: boolean;
-
-  error?: Error;
-  errorData?: any;
-
-  hasAnyPermission: (permissions: string[]) => boolean;
-  updateStorage: (storage: Record<string, any>) => void;
-}
-
-export const currentUserStore = create<ICurrentUserStore>((set, get) => ({
-  currentUser: undefined,
-  loading: false,
-  error: undefined,
-  load: async () => {
-    set({ loading: true });
-
-    let response: IReqraftFetchResponse<ICurrentUser>;
-
-    try {
-      response = await query<ICurrentUser>({ url: 'users?action=current', cache: false });
-    } catch (error) {
-      /* An abandoned request (the query cache was cleared while it was in
-         flight) is not a user that could not be loaded: the store keeps what it
-         had and only stops loading - without that, `loading` stayed true for
-         good and a `waitForStorage` provider rendered nothing. Anything else
-         that throws is a load that failed, and is kept as one. */
-      if (isQueryCancelled(error)) {
-        set({ loading: false });
-      } else {
-        set({
-          loading: false,
-          error: error as Error,
-          currentUser: undefined,
-          errorData: undefined,
-        });
-      }
-
-      return Promise.reject(error);
-    }
-
-    if (!response.ok) {
-      set({
-        loading: false,
-        error: response.error,
-        currentUser: undefined,
-        errorData: response.data,
-      });
-
-      return Promise.reject(response.error);
-    }
-
-    set({ currentUser: response.data, loading: false, errorData: undefined, error: undefined });
-
-    return response.data;
-  },
-  hasAnyPermission: (permissions) => {
-    if (!get().currentUser) {
-      return false;
-    }
-
-    const { currentUser } = get();
-
-    return permissions.some((permission) => currentUser.permissions?.includes(permission));
-  },
-  updateStorage: (storage) => {
-    set((state) => ({ currentUser: { ...state.currentUser, storage } }));
-  },
-}));

package/src/stories/Data/fileFieldArgSchema.json

@@ -1,86 +0,0 @@
-{
-  "name": {
-    "type": "richtext",
-    "ui_type": "richtext",
-    "desc": "The filename",
-    "required": true,
-    "supports_templates": true,
-    "supports_expressions": true,
-    "display_name": "Filename",
-    "short_desc": "The filename"
-  },
-  "content": {
-    "type": "richtext",
-    "ui_type": "richtext",
-    "desc": "Base64-encoded file data",
-    "required": true,
-    "supports_templates": true,
-    "supports_expressions": true,
-    "display_name": "File Data",
-    "short_desc": "Base64-encoded file data"
-  },
-  "mime_type": {
-    "allowed_values": [
-      {
-        "display_name": "Autodetect",
-        "short_desc": "Autodetect from the file name; valid only on input",
-        "value": { "type": "string", "value": "auto" },
-        "desc": "Autodetect from the file name; valid only on input"
-      },
-      {
-        "display_name": "text/plain",
-        "short_desc": "Plain text",
-        "value": { "type": "string", "value": "text/plain" },
-        "desc": "Plain text"
-      },
-      {
-        "display_name": "text/html",
-        "short_desc": "HTML text",
-        "value": { "type": "string", "value": "text/html" },
-        "desc": "HTML text"
-      },
-      {
-        "display_name": "application/pdf",
-        "short_desc": "PDF file",
-        "value": { "type": "string", "value": "application/pdf" },
-        "desc": "PDF file"
-      },
-      {
-        "display_name": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-        "short_desc": "MS Word docx document",
-        "value": {
-          "type": "string",
-          "value": "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
-        },
-        "desc": "MS Word `docx` document"
-      },
-      {
-        "display_name": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
-        "short_desc": "MS PowerPoint pptx document",
-        "value": {
-          "type": "string",
-          "value": "application/vnd.openxmlformats-officedocument.presentationml.presentation"
-        },
-        "desc": "MS PowerPoint `pptx` document"
-      },
-      {
-        "display_name": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-        "short_desc": "MS Excel xlsx document",
-        "value": {
-          "type": "string",
-          "value": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
-        },
-        "desc": "MS Excel `xlsx` document"
-      }
-    ],
-    "allowed_values_creatable": true,
-    "type": "richtext",
-    "ui_type": "richtext",
-    "desc": "The MIME type string for the file",
-    "required": true,
-    "supports_templates": true,
-    "supports_expressions": true,
-    "display_name": "MIME Type",
-    "short_desc": "The MIME type string for the file"
-  }
-}