@nyris/nyris-webapp 0.3.98 → 0.4.0

package/src/services/initialMachinePartsText.payload.test.ts

@@ -0,0 +1,61 @@
+import NyrisAPI, { NyrisAPISettings } from '@nyris/nyris-api';
+
+function entries(body: FormData) {
+  return Array.from(body.entries()).map(([key, value]) => [key, String(value)]);
+}
+
+async function capture(
+  text: string | undefined,
+  scopeIds: string[],
+) {
+  const api = new NyrisAPI({
+    apiKey: 'test-key',
+    baseUrl: 'https://api.nyris.io',
+    jpegQuality: 0.9,
+    maxWidth: 1024,
+    maxHeight: 1024,
+    xOptions: false,
+  } as NyrisAPISettings);
+  const request = jest.fn().mockResolvedValue({ data: { results: [] } });
+  (api as unknown as { httpClient: { request: jest.Mock } }).httpClient = {
+    request,
+  };
+  await api.find(
+    text !== undefined ? { text } : {},
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    scopeIds,
+  );
+  return request.mock.calls[0][0] as {
+    url: string;
+    data: FormData | null;
+  };
+}
+
+describe('initial machine find payload', () => {
+  it('sends the caller-provided item-key batch and scope id', async () => {
+    const itemKeys = Array.from(
+      { length: 15 },
+      (_, index) => `ITEM-${index + 1}`,
+    );
+    const text = itemKeys.slice(10).join(', ');
+    const config = await capture(text, ['TestScope2']);
+
+    expect(config.url).toBe('https://api.nyris.io/find/v1.1');
+    expect(entries(config.data as FormData)).toEqual([
+      ['text', text],
+      ['scope[0]', 'TestScope2'],
+    ]);
+  });
+
+  it('sends a keyword without item keys when a machine scope is active', async () => {
+    const config = await capture('pump', ['TestScope2']);
+
+    expect(entries(config.data as FormData)).toEqual([
+      ['text', 'pump'],
+      ['scope[0]', 'TestScope2'],
+    ]);
+  });
+});

package/src/services/initialMachinePartsText.test.ts

@@ -0,0 +1,33 @@
+import { initialMachinePartsText } from './initialMachinePartsText';
+
+function keys(count: number) {
+  return Array.from({ length: count }, (_, index) => `ITEM-${index + 1}`);
+}
+
+describe('initialMachinePartsText', () => {
+  it('joins fewer than 20 item keys in order', () => {
+    const itemKeys = keys(3);
+    expect(initialMachinePartsText(itemKeys)).toBe(
+      'ITEM-1, ITEM-2, ITEM-3',
+    );
+    expect(itemKeys).toEqual(keys(3));
+  });
+
+  it('joins exactly 20 item keys', () => {
+    const text = initialMachinePartsText(keys(20));
+    expect(text?.split(', ')).toHaveLength(20);
+    expect(text?.endsWith('ITEM-20')).toBe(true);
+  });
+
+  it('stops at the first 20 item keys', () => {
+    const itemKeys = keys(21);
+    const text = initialMachinePartsText(itemKeys);
+    expect(text?.split(', ')).toHaveLength(20);
+    expect(text?.includes('ITEM-21')).toBe(false);
+    expect(itemKeys).toHaveLength(21);
+  });
+
+  it('returns undefined when there are no item keys', () => {
+    expect(initialMachinePartsText([])).toBeUndefined();
+  });
+});

package/src/services/initialMachinePartsText.ts

@@ -0,0 +1,11 @@
+import {
+  DEFAULT_MACHINE_PARTS_PAGE_SIZE,
+  machinePartsPageText,
+} from './machinePartsPage';
+
+/** First page at the default page size. The source array is not changed. */
+export function initialMachinePartsText(
+  itemKeys: readonly string[],
+): string | undefined {
+  return machinePartsPageText(itemKeys, 0, DEFAULT_MACHINE_PARTS_PAGE_SIZE);
+}

package/src/services/machinePartsPage.test.ts

@@ -0,0 +1,74 @@
+import {
+  isScopeOnlyMachinePartsListing,
+  machinePartsPageCount,
+  machinePartsPageItemKeys,
+  machinePartsPageText,
+  visibleMachinePartsPageIndexes,
+} from './machinePartsPage';
+
+function keys(count: number) {
+  return Array.from({ length: count }, (_, index) => `ITEM-${index + 1}`);
+}
+
+describe('machinePartsPage', () => {
+  it('splits 15 item keys into pages of 10 without overlap', () => {
+    const itemKeys = keys(15);
+    expect(machinePartsPageCount(itemKeys.length, 10)).toBe(2);
+    expect(machinePartsPageItemKeys(itemKeys, 0, 10)).toEqual(keys(10));
+    expect(machinePartsPageItemKeys(itemKeys, 1, 10)).toEqual(
+      keys(15).slice(10),
+    );
+    expect(machinePartsPageText(itemKeys, 1, 10)).toBe(
+      'ITEM-11, ITEM-12, ITEM-13, ITEM-14, ITEM-15',
+    );
+    expect(itemKeys).toHaveLength(15);
+  });
+
+  it('counts pages for 611 item keys from the key list, not the response', () => {
+    expect(machinePartsPageCount(611, 10)).toBe(62);
+    expect(machinePartsPageCount(611, 20)).toBe(31);
+    expect(machinePartsPageCount(611, 30)).toBe(21);
+    expect(machinePartsPageCount(611, 40)).toBe(16);
+    expect(machinePartsPageCount(611, 50)).toBe(13);
+
+    const itemKeys = keys(611);
+    const lastPage = machinePartsPageItemKeys(itemKeys, 30, 20);
+    expect(lastPage).toHaveLength(11);
+    expect(lastPage[0]).toBe('ITEM-601');
+    expect(lastPage[lastPage.length - 1]).toBe('ITEM-611');
+  });
+
+  it('keeps a full last page when the key count divides evenly', () => {
+    expect(machinePartsPageCount(10000, 50)).toBe(200);
+    expect(machinePartsPageItemKeys(keys(10000), 199, 50)).toHaveLength(50);
+  });
+
+  it('returns no text for an empty page', () => {
+    expect(machinePartsPageText(keys(15), 2, 10)).toBeUndefined();
+    expect(machinePartsPageCount(0, 20)).toBe(0);
+  });
+
+  it('shows every page when the count fits, otherwise a window', () => {
+    expect(visibleMachinePartsPageIndexes(0, 2)).toEqual([0, 1]);
+    expect(visibleMachinePartsPageIndexes(0, 62)).toHaveLength(7);
+    expect(visibleMachinePartsPageIndexes(61, 62)).toContain(61);
+  });
+
+  it('treats an active machine scope as a listing even if Algolia is on', () => {
+    const listing = {
+      scopeEnabled: true,
+      scopeId: 'TestScope2',
+      itemKeyCount: 15,
+      keyword: '',
+      hasSearchImage: false,
+      hasPostFilters: false,
+    };
+    expect(isScopeOnlyMachinePartsListing(listing)).toBe(true);
+    expect(
+      isScopeOnlyMachinePartsListing({ ...listing, keyword: 'pump' }),
+    ).toBe(false);
+    expect(
+      isScopeOnlyMachinePartsListing({ ...listing, scopeEnabled: false }),
+    ).toBe(false);
+  });
+});

package/src/services/machinePartsPage.ts

@@ -0,0 +1,120 @@
+export const DEFAULT_MACHINE_PARTS_PAGE_SIZE = 20;
+
+export function normalizeMachinePartsPageSize(pageSize: number): number {
+  if (!Number.isFinite(pageSize) || pageSize <= 0) {
+    return DEFAULT_MACHINE_PARTS_PAGE_SIZE;
+  }
+  return Math.floor(pageSize);
+}
+
+/** 0-based page index, matching the existing pagination control. */
+export function normalizeMachinePartsPageIndex(pageIndex: number): number {
+  if (!Number.isFinite(pageIndex) || pageIndex <= 0) {
+    return 0;
+  }
+  return Math.floor(pageIndex);
+}
+
+export function machinePartsPageCount(
+  itemKeyCount: number,
+  pageSize: number,
+): number {
+  if (!Number.isFinite(itemKeyCount) || itemKeyCount <= 0) {
+    return 0;
+  }
+  const size = normalizeMachinePartsPageSize(pageSize);
+  return Math.ceil(itemKeyCount / size);
+}
+
+/** Does not mutate `itemKeys`. */
+export function machinePartsPageItemKeys(
+  itemKeys: readonly string[],
+  pageIndex: number,
+  pageSize: number,
+): string[] {
+  const size = normalizeMachinePartsPageSize(pageSize);
+  const start = normalizeMachinePartsPageIndex(pageIndex) * size;
+  return itemKeys.slice(start, start + size);
+}
+
+export function machinePartsPageText(
+  itemKeys: readonly string[],
+  pageIndex: number,
+  pageSize: number,
+): string | undefined {
+  const text = machinePartsPageItemKeys(itemKeys, pageIndex, pageSize).join(
+    ', ',
+  );
+  if (text.length === 0) {
+    return undefined;
+  }
+  return text;
+}
+
+/** Page numbers shown around the current page. Indexes are 0-based. */
+export function visibleMachinePartsPageIndexes(
+  pageIndex: number,
+  pageCount: number,
+  padding = 3,
+): number[] {
+  if (pageCount <= 0) {
+    return [];
+  }
+  const current = Math.min(
+    normalizeMachinePartsPageIndex(pageIndex),
+    pageCount - 1,
+  );
+  if (pageCount <= padding * 2 + 1) {
+    return Array.from({ length: pageCount }, (_, index) => index);
+  }
+
+  let start = Math.max(0, current - padding);
+  let end = Math.min(pageCount - 1, current + padding);
+  if (current - padding < 0) {
+    end = Math.min(pageCount - 1, end + (padding - current));
+  }
+  if (current + padding > pageCount - 1) {
+    start = Math.max(0, start - (current + padding - (pageCount - 1)));
+  }
+
+  const pages: number[] = [];
+  for (let index = start; index <= end; index += 1) {
+    pages.push(index);
+  }
+  return pages;
+}
+
+export function hasActivePostFilters(
+  selections: Record<string, string[]> | undefined,
+): boolean {
+  return Object.values(selections || {}).some(
+    values => Array.isArray(values) && values.length > 0,
+  );
+}
+
+export function isScopeOnlyMachinePartsListing({
+  scopeEnabled,
+  scopeId,
+  itemKeyCount,
+  keyword,
+  hasSearchImage,
+  hasPostFilters,
+}: {
+  scopeEnabled: boolean;
+  scopeId: string | null;
+  itemKeyCount: number;
+  keyword: string;
+  hasSearchImage: boolean;
+  hasPostFilters: boolean;
+}): boolean {
+  if (!scopeEnabled) {
+    return false;
+  }
+  if (!scopeId || itemKeyCount <= 0) {
+    return false;
+  }
+  if (keyword.trim().length > 0 || hasSearchImage || hasPostFilters) {
+    return false;
+  }
+  return true;
+}

package/src/services/normalizeChatResponse.ts

@@ -0,0 +1,26 @@
+/**
+ * The chat API sometimes returns the JSON payload as a string, optionally
+ * wrapped in a markdown code fence (```json ... ```). Parse such strings into
+ * objects; leave plain-text responses (e.g. request_quality) untouched.
+ *
+ * A JSON object embedded in surrounding text is left as text. Callers must not
+ * treat that leftover text as structured data.
+ */
+export function normalizeChatResponse(data: unknown): unknown {
+  if (typeof data !== 'string') {
+    return data;
+  }
+
+  const fenced = data.match(/```(?:json)?\s*([\s\S]*?)\s*```/i);
+  const candidate = (fenced ? fenced[1] : data).trim();
+
+  if (!candidate.startsWith('{') && !candidate.startsWith('[')) {
+    return data;
+  }
+
+  try {
+    return JSON.parse(candidate);
+  } catch {
+    return data;
+  }
+}

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}`);