@nyris/nyris-webapp 0.3.98 → 0.3.99

package/src/services/scopeLookup.test.ts

@@ -0,0 +1,67 @@
+import { getScopes } from 'services/filter';
+import { lookupScopeById } from './scopeLookup';
+
+jest.mock('services/filter', () => ({
+  getScopes: jest.fn(),
+}));
+
+jest.mock('utils/nyrisApiKey', () => ({
+  isNyrisApiKeyReady: () => true,
+}));
+
+const getScopesMock = getScopes as jest.MockedFunction<typeof getScopes>;
+
+describe('lookupScopeById', () => {
+  beforeEach(() => {
+    getScopesMock.mockReset();
+    window.settings = {
+      scopes: { scopeID: true },
+      apiKey: 'test-key',
+    } as typeof window.settings;
+  });
+
+  it('sends the serial number unchanged', async () => {
+    getScopesMock.mockResolvedValue({
+      itemKeys: ['sku-1'],
+      filterAttributes: [],
+    });
+
+    const result = await lookupScopeById('Ab-12/c 9');
+
+    expect(getScopesMock).toHaveBeenCalledWith(
+      'Ab-12/c 9',
+      window.settings,
+    );
+    expect(result).toEqual({
+      status: 'found',
+      itemKeys: ['sku-1'],
+      filterAttributes: [],
+    });
+  });
+
+  it('does not call the scopes API for a blank id', async () => {
+    const result = await lookupScopeById('   ');
+
+    expect(getScopesMock).not.toHaveBeenCalled();
+    expect(result).toEqual({ status: 'not_found' });
+  });
+
+  it('returns empty when the machine has no item keys', async () => {
+    getScopesMock.mockResolvedValue({
+      itemKeys: [],
+      filterAttributes: [],
+    });
+
+    await expect(lookupScopeById('2234GH')).resolves.toEqual({
+      status: 'empty',
+    });
+  });
+
+  it('returns not found when the scopes request fails', async () => {
+    getScopesMock.mockRejectedValue(new Error('unavailable'));
+
+    await expect(lookupScopeById('2234GH')).resolves.toEqual({
+      status: 'not_found',
+    });
+  });
+});

package/src/services/scopeLookup.ts

@@ -0,0 +1,39 @@
+import { getScopes } from 'services/filter';
+import { isNyrisApiKeyReady } from 'utils/nyrisApiKey';
+import { TypePlateLookupResult } from 'components/ScopeSelect/identifyTypePlateImage';
+
+/**
+ * GET /v1/scopes?scopeIds=... using the existing client encoding.
+ * Does not write the scope store. Callers apply a machine only after confirm.
+ * The id is sent unchanged; trimming only rejects a blank value.
+ */
+export async function lookupScopeById(
+  scopeId: string,
+): Promise<TypePlateLookupResult> {
+  const settings = window.settings;
+  if (!settings.scopes?.scopeID) {
+    return { status: 'unavailable' };
+  }
+
+  if (!isNyrisApiKeyReady()) {
+    return { status: 'unavailable' };
+  }
+
+  if (scopeId.trim().length === 0 || scopeId.trim() === 'NOT_FOUND') {
+    return { status: 'not_found' };
+  }
+
+  try {
+    const scopesResponse = await getScopes(scopeId, settings);
+    const itemKeys = (scopesResponse.itemKeys || []).filter(Boolean);
+    const filterAttributes = scopesResponse.filterAttributes || [];
+
+    if (itemKeys.length === 0) {
+      return { status: 'empty' };
+    }
+
+    return { status: 'found', itemKeys, filterAttributes };
+  } catch {
+    return { status: 'not_found' };
+  }
+}

package/src/services/visualSearch.listingOptions.test.ts

@@ -0,0 +1,79 @@
+import { machinePartsPageText } from './machinePartsPage';
+import { machinePartsListingXOptions } from './visualSearch';
+
+const X_OPTIONS = 'hybrid_search.text.reranking=false';
+
+function keys(count: number) {
+  return Array.from({ length: count }, (_, index) => `ITEM-${index + 1}`);
+}
+
+const listing = {
+  hasSearchImage: false,
+  hasFilters: false,
+  scopeId: 'TestScope2',
+  itemKeys: keys(15),
+  keyword: '',
+  pageSize: 10,
+};
+
+describe('machinePartsListingXOptions', () => {
+  it('sends the override for each scope-only item key page', () => {
+    expect(
+      machinePartsListingXOptions({
+        ...listing,
+        pageIndex: 0,
+        text: machinePartsPageText(listing.itemKeys, 0, 10),
+      }),
+    ).toBe(X_OPTIONS);
+    expect(
+      machinePartsListingXOptions({
+        ...listing,
+        pageIndex: 1,
+        text: machinePartsPageText(listing.itemKeys, 1, 10),
+      }),
+    ).toBe(X_OPTIONS);
+  });
+
+  it('omits the override for a keyword, image, filters, or another page', () => {
+    const firstPage = machinePartsPageText(listing.itemKeys, 0, 10);
+    expect(
+      machinePartsListingXOptions({
+        ...listing,
+        pageIndex: 1,
+        text: firstPage,
+      }),
+    ).toBeUndefined();
+    expect(
+      machinePartsListingXOptions({
+        ...listing,
+        pageIndex: 0,
+        text: 'pump',
+        keyword: 'pump',
+      }),
+    ).toBeUndefined();
+    expect(
+      machinePartsListingXOptions({
+        ...listing,
+        pageIndex: 0,
+        text: firstPage,
+        hasSearchImage: true,
+      }),
+    ).toBeUndefined();
+    expect(
+      machinePartsListingXOptions({
+        ...listing,
+        pageIndex: 0,
+        text: firstPage,
+        hasFilters: true,
+      }),
+    ).toBeUndefined();
+    expect(
+      machinePartsListingXOptions({
+        ...listing,
+        pageIndex: 0,
+        text: firstPage,
+        scopeId: null,
+      }),
+    ).toBeUndefined();
+  });
+});

package/src/services/visualSearch.ts

@@ -10,6 +10,45 @@ import { isEqual } from 'lodash';
 import { DEFAULT_REGION } from '../constants';
 import { getUserLocation } from 'helpers/getGeoLocation';
 import { getNyrisSettings } from 'utils/nyrisApiKey';
+import useRequestStore from 'stores/request/requestStore';
+import useScopeStore from 'stores/scope/scopeStore';
+import { machinePartsPageText } from './machinePartsPage';
+import useMachinePartsListingStore from 'stores/machinePartsListing/machinePartsListingStore';
+
+const MACHINE_PARTS_LISTING_X_OPTIONS = 'hybrid_search.text.reranking=false';
+
+/** Scope-only listing: generated item-key text, no keyword, image, or filters. */
+export function machinePartsListingXOptions({
+  text,
+  hasSearchImage,
+  hasFilters,
+  scopeId,
+  itemKeys,
+  keyword,
+  pageIndex,
+  pageSize,
+}: {
+  text?: string;
+  hasSearchImage: boolean;
+  hasFilters: boolean;
+  scopeId: string | null;
+  itemKeys: readonly string[];
+  keyword: string;
+  pageIndex: number;
+  pageSize: number;
+}): string | undefined {
+  if (!scopeId || hasSearchImage || hasFilters) {
+    return undefined;
+  }
+  const listingText = machinePartsPageText(itemKeys, pageIndex, pageSize);
+  if (!listingText || text !== listingText) {
+    return undefined;
+  }
+  if (keyword.trim().length > 0) {
+    return undefined;
+  }
+  return MACHINE_PARTS_LISTING_X_OPTIONS;
+}
 
 export interface Filter {
   key?: string;
@@ -53,6 +92,18 @@ export const findRegions = async (
   };
 };
 
+/** Validated machine scope id. Item keys from /v1/scopes are not used. */
+function appliedMachineScopeId(): string | null {
+  if (!window.settings?.scopes?.scopeID) {
+    return null;
+  }
+  const { scopeId } = useScopeStore.getState();
+  if (typeof scopeId !== 'string' || scopeId.trim().length === 0) {
+    return null;
+  }
+  return scopeId;
+}
+
 export const find = async ({
   image,
   settings,
@@ -69,7 +120,8 @@ export const find = async ({
   scopeIds?: string;
 }) => {
   const nyrisApi = new NyrisAPI(getNyrisSettings(settings));
-  let options: ImageSearchOptions = text ? { text } : {};
+  let options: ImageSearchOptions =
+    typeof text === 'string' && text.length > 0 ? { text } : {};
 
   if (window.settings?.geoLocation) {
     try {
@@ -85,13 +137,29 @@ export const find = async ({
   if (region) {
     options = { ...options, cropRect: region };
   }
+  const machineScopeId = appliedMachineScopeId();
+  const listingPage = useMachinePartsListingStore.getState();
+  const xOptions = machinePartsListingXOptions({
+    text,
+    hasSearchImage: Boolean(image),
+    hasFilters: Boolean(filters && filters.length > 0),
+    scopeId: machineScopeId,
+    itemKeys: useScopeStore.getState().itemKeys || [],
+    keyword: useRequestStore.getState().query || '',
+    pageIndex: listingPage.pageIndex,
+    pageSize: listingPage.pageSize,
+  });
   return nyrisApi.find(
     options,
     image,
     filters,
     undefined,
-    undefined,
-    scopeIds ? [scopeIds] : [],
+    xOptions,
+    machineScopeId
+      ? [machineScopeId]
+      : scopeIds
+        ? [scopeIds]
+        : [],
   );
 };
 

package/src/services/vizo.ts

@@ -2,6 +2,7 @@ import { RectCoords } from '@nyris/nyris-api';
 import axios from 'axios';
 import { cropImage } from 'utils/cropImageToBase64';
 import { getEffectiveApiKey } from 'utils/nyrisApiKey';
+import { normalizeChatResponse } from './normalizeChatResponse';
 
 function resolveAiOrNyrisApiKey(explicitApiKey?: string): string {
   if (explicitApiKey) {
@@ -330,20 +331,20 @@ export async function chatAnalysis({
 }: ChatAnalysisParams): Promise<any> {
   try {
     const response = await axios.post(
-      'https://api.nyris.io/api/ai-analysis/chat',
+      `${window.settings.baseUrl}/api/ai-analysis/chat`,
       {
         promptKey,
         multimodalInputs,
       },
       {
         headers: {
-          'x-api-key': apiKey || window.settings.aiApiKey || '',
+          'x-api-key': resolveAiOrNyrisApiKey(apiKey),
           'Content-Type': 'application/json',
         },
       },
     );
 
-    return response.data;
+    return normalizeChatResponse(response.data);
   } catch (error: any) {
     if (error.response) {
       throw new Error(`API error: ${error.response.statusText}`);

package/src/stores/machinePartsListing/machinePartsListingStore.ts

@@ -0,0 +1,35 @@
+import { create } from 'zustand';
+import {
+  DEFAULT_MACHINE_PARTS_PAGE_SIZE,
+  machinePartsPageText,
+} from 'services/machinePartsPage';
+import useScopeStore from 'stores/scope/scopeStore';
+
+interface MachinePartsListingState {
+  pageSize: number;
+  pageIndex: number;
+  setPageSize: (pageSize: number) => void;
+  setPageIndex: (pageIndex: number) => void;
+  resetPage: () => void;
+}
+
+const useMachinePartsListingStore = create<MachinePartsListingState>()(set => ({
+  pageSize: DEFAULT_MACHINE_PARTS_PAGE_SIZE,
+  pageIndex: 0,
+  setPageSize: pageSize => set({ pageSize, pageIndex: 0 }),
+  setPageIndex: pageIndex => set({ pageIndex }),
+  resetPage: () => set({ pageIndex: 0 }),
+}));
+
+/** Scope-only listing restarts at page 1 and keeps the selected page size. */
+export function firstMachinePartsListingText(): string | undefined {
+  useMachinePartsListingStore.getState().resetPage();
+  const { pageSize } = useMachinePartsListingStore.getState();
+  return machinePartsPageText(
+    useScopeStore.getState().itemKeys || [],
+    0,
+    pageSize,
+  );
+}
+
+export default useMachinePartsListingStore;

package/src/stores/request/filter/filter.initialState.ts

@@ -8,4 +8,5 @@ export const initialState: FilterState = {
   specificationFilter: {},
   postFilterSelections: {},
   preFilterLoading: false,
+  typePlatePreFilterValues: [],
 };

package/src/stores/request/filter/filter.slice.ts

@@ -13,6 +13,8 @@ const filterSlice: StateCreator<FilterState & FilterAction> = set => ({
   setPreFilterList: filter => set(() => ({ preFilterList: filter })),
   setPreFilterLoading: isLoading =>
     set(() => ({ preFilterLoading: isLoading })),
+  setTypePlatePreFilterValues: values =>
+    set(() => ({ typePlatePreFilterValues: values })),
   setPostFilterSelections: filters =>
     set(() => ({ postFilterSelections: filters })),
   togglePostFilterSelection: (attribute, value) =>

package/src/stores/result/prodcuts/products.initialState.ts

@@ -31,6 +31,7 @@ export const initialState: ProductsState = {
     rerankStatus: 'idle',
     errorMessage: null,
   },
+  requestQuality: null,
   postFilterFacets: [],
   initialFindSearchSnapshot: null,
 };

package/src/stores/result/prodcuts/products.slice.ts

@@ -61,6 +61,10 @@ const productsSlice: StateCreator<ProductsState & ProductsAction> = set => ({
     set(() => ({
       smartFilters,
     })),
+  setRequestQuality: requestQuality =>
+    set(() => ({
+      requestQuality,
+    })),
   setPostFilterFacets: facets =>
     set(() => ({
       postFilterFacets: facets,

package/src/stores/scope/scopeStore.ts

@@ -1,35 +1,98 @@
 import { create } from 'zustand';
 import { Filter } from '@nyris/nyris-api';
 
+export type ScopeSource = 'manual' | 'image';
+
+export type AppliedScopeInput =
+  | { source: 'manual'; value: string }
+  | { source: 'image'; fileKey: string };
+
 interface ScopeState {
   itemKeys: string[];
   filterAttributes: Filter[];
+  scopeId: string | null;
   isLoading: boolean;
   hasFetched: boolean;
+  formResetKey: number;
+  manualScopeId: string;
+  pendingFile: File | null;
+  previewUrl: string | null;
+  activeSource: ScopeSource | null;
+  lastAppliedInput: AppliedScopeInput | null;
+  lastExtractedFromImage: string;
 }
 
 interface ScopeAction {
-  setScope: (itemKeys: string[], filterAttributes: Filter[]) => void;
+  setScope: (
+    itemKeys: string[],
+    filterAttributes: Filter[],
+    scopeId?: string | null,
+  ) => void;
   setScopeLoading: (isLoading: boolean) => void;
   setScopeFetched: (hasFetched: boolean) => void;
+  setManualScopeId: (manualScopeId: string) => void;
+  setPendingFile: (pendingFile: File | null) => void;
+  setPreviewUrl: (previewUrl: string | null) => void;
+  setActiveSource: (activeSource: ScopeSource | null) => void;
+  setLastAppliedInput: (lastAppliedInput: AppliedScopeInput | null) => void;
+  setLastExtractedFromImage: (lastExtractedFromImage: string) => void;
   resetScope: () => void;
 }
 
 const initialState: ScopeState = {
   itemKeys: [],
   filterAttributes: [],
+  scopeId: null,
   isLoading: false,
   hasFetched: false,
+  formResetKey: 0,
+  manualScopeId: '',
+  pendingFile: null,
+  previewUrl: null,
+  activeSource: null,
+  lastAppliedInput: null,
+  lastExtractedFromImage: '',
 };
 
 const useScopeStore = create<ScopeState & ScopeAction>()(set => ({
   ...initialState,
 
-  setScope: (itemKeys, filterAttributes) =>
-    set({ itemKeys, filterAttributes, hasFetched: true }),
+  setScope: (itemKeys, filterAttributes, scopeId = null) =>
+    set({ itemKeys, filterAttributes, scopeId, hasFetched: true }),
   setScopeLoading: isLoading => set({ isLoading }),
   setScopeFetched: hasFetched => set({ hasFetched }),
-  resetScope: () => set(initialState),
+  setManualScopeId: manualScopeId => set({ manualScopeId }),
+  setPendingFile: pendingFile => set({ pendingFile }),
+  setPreviewUrl: previewUrl => set({ previewUrl }),
+  setActiveSource: activeSource => set({ activeSource }),
+  setLastAppliedInput: lastAppliedInput => set({ lastAppliedInput }),
+  setLastExtractedFromImage: lastExtractedFromImage =>
+    set({ lastExtractedFromImage }),
+  resetScope: () =>
+    set(state => {
+      if (state.previewUrl) {
+        try {
+          URL.revokeObjectURL(state.previewUrl);
+        } catch {}
+      }
+      return {
+        ...initialState,
+        formResetKey: state.formResetKey + 1,
+      };
+    }),
 }));
 
+/** Machine scope that should constrain the results currently on screen. */
+export function hasActiveMachineScope(): boolean {
+  if (!window.settings?.scopes?.scopeID) {
+    return false;
+  }
+  const { scopeId, itemKeys } = useScopeStore.getState();
+  return (
+    typeof scopeId === 'string' &&
+    scopeId.trim().length > 0 &&
+    itemKeys.length > 0
+  );
+}
+
 export default useScopeStore;

package/src/stores/types.ts

@@ -71,20 +71,21 @@ export interface ProductsState {
   groundingError: string | null;
   firstAlgoliaProducts: any[];
   fullResultPool: any[];
-    smartFilters: {
-        status: 'idle' | 'loading' | 'success' | 'error';
-        filters: Array<{
-            key: string;
-            label: string;
-            value: string;
-            selected?: boolean;
-        }>;
-        selectedFilterKey: string | null;
-        selectedFilterValue: string | null;
-        rerankedSkus: string[];
-        rerankStatus: 'idle' | 'loading' | 'success' | 'error';
-        errorMessage: string | null;
-    };
+  smartFilters: {
+    status: 'idle' | 'loading' | 'success' | 'error';
+    filters: Array<{
+      key: string;
+      label: string;
+      value: string;
+      selected?: boolean;
+    }>;
+    selectedFilterKey: string | null;
+    selectedFilterValue: string | null;
+    rerankedSkus: string[];
+    rerankStatus: 'idle' | 'loading' | 'success' | 'error';
+    errorMessage: string | null;
+  };
+  requestQuality: string | null;
   postFilterFacets: any[];
   initialFindSearchSnapshot: {
     results: any[];
@@ -110,6 +111,7 @@ export interface ProductsAction {
   setFullResultPool: (products: any[]) => void;
   resetGrounding: () => void;
   setSmartFilters: (smartFilters: ProductsState['smartFilters']) => void;
+  setRequestQuality: (requestQuality: string | null) => void;
   setPostFilterFacets: (facets: any[]) => void;
   setInitialFindSearchSnapshot: (
     snapshot: ProductsState['initialFindSearchSnapshot'],
@@ -132,6 +134,8 @@ export interface FilterState {
   specificationFilter: Record<string, string>;
   postFilterSelections: Record<string, string[]>;
   preFilterLoading: boolean;
+  // Values applied from type-plate upload; cleared independently of manual picks.
+  typePlatePreFilterValues: string[];
 }
 
 export interface FilterAction {
@@ -144,6 +148,7 @@ export interface FilterAction {
   togglePostFilterSelection: (attribute: string, value: string) => void;
   clearPostFilterSelections: () => void;
   setPreFilterLoading: (isLoading: boolean) => void;
+  setTypePlatePreFilterValues: (values: string[]) => void;
 }
 
 export interface MiscState {