@unchainedshop/api 4.0.0-rc.2 → 4.0.0-rc.21

package/src/loaders/assortmentLinksLoader.ts

@@ -7,9 +7,9 @@ export default (unchainedAPI: UnchainedCore) =>
     { parentAssortmentId?: string; childAssortmentId?: string; assortmentId?: string },
     AssortmentLink[]
   >(async (queries) => {
-    const parentAssortmentIds = queries.flatMap((q) => q.parentAssortmentId).filter(Boolean);
-    const childAssortmentIds = queries.flatMap((q) => q.childAssortmentId).filter(Boolean);
-    const assortmentIds = queries.flatMap((q) => q.assortmentId).filter(Boolean);
+    const parentAssortmentIds = queries.flatMap((q) => q.parentAssortmentId).filter(Boolean) as string[];
+    const childAssortmentIds = queries.flatMap((q) => q.childAssortmentId).filter(Boolean) as string[];
+    const assortmentIds = queries.flatMap((q) => q.assortmentId).filter(Boolean) as string[];
 
     const allLinks = await unchainedAPI.modules.assortments.links.findLinks({
       assortmentIds: [...new Set([...parentAssortmentIds, ...childAssortmentIds, ...assortmentIds])],
@@ -38,9 +38,12 @@ export default (unchainedAPI: UnchainedCore) =>
       } else if (q.childAssortmentId) {
         return childAssortmentLinkMap[q.childAssortmentId] || [];
       }
-      return [
-        ...(parentAssortmentLinkMap[q.assortmentId] || []),
-        ...(childAssortmentLinkMap[q.assortmentId] || []),
-      ];
+      if (q.assortmentId) {
+        return [
+          ...(parentAssortmentLinkMap[q.assortmentId] || []),
+          ...(childAssortmentLinkMap[q.assortmentId] || []),
+        ];
+      }
+      return [];
     });
   });

package/src/loaders/assortmentMediaTextLoader.ts

@@ -1,8 +1,8 @@
 import { UnchainedCore } from '@unchainedshop/core';
 import { AssortmentMediaText } from '@unchainedshop/core-assortments';
 import DataLoader from 'dataloader';
-import { buildLocaleMap } from './utils.js';
 import buildTextMap from './buildTextMap.js';
+import buildLocaleMap from './buildLocaleMap.js';
 
 export default (unchainedAPI: UnchainedCore) =>
   new DataLoader<{ assortmentMediaId: string; locale: Intl.Locale }, AssortmentMediaText>(

package/src/loaders/assortmentMediasLoader.ts

@@ -3,7 +3,7 @@ import { AssortmentMediaType } from '@unchainedshop/core-assortments';
 import DataLoader from 'dataloader';
 
 export default (unchainedAPI: UnchainedCore) =>
-  new DataLoader<{ assortmentId?: string }, AssortmentMediaType[]>(async (queries) => {
+  new DataLoader<{ assortmentId: string }, AssortmentMediaType[]>(async (queries) => {
     const assortmentIds = [...new Set(queries.map((q) => q.assortmentId).filter(Boolean))];
     const assortmentMediaItems = await unchainedAPI.modules.assortments.media.findAssortmentMedias({
       assortmentId: { $in: assortmentIds },

package/src/loaders/assortmentTextLoader.ts

@@ -1,8 +1,8 @@
 import { UnchainedCore } from '@unchainedshop/core';
 import { AssortmentText } from '@unchainedshop/core-assortments';
 import DataLoader from 'dataloader';
-import { buildLocaleMap } from './utils.js';
 import buildTextMap from './buildTextMap.js';
+import buildLocaleMap from './buildLocaleMap.js';
 
 export default (unchainedAPI: UnchainedCore) =>
   new DataLoader<{ assortmentId: string; locale: Intl.Locale }, AssortmentText>(async (queries) => {

package/src/loaders/buildLocaleMap.test.ts

@@ -0,0 +1,65 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import buildLocaleMap from './buildLocaleMap.js';
+
+const testTexts = [
+  // 1 has translations in French and German
+  { locale: 'fr', _id: '1', entityId: '1' },
+  { locale: 'de', _id: '2', entityId: '1' },
+
+  // 2 only has Ialien translations
+  { locale: 'it', _id: '3', entityId: '2' },
+
+  // 3 only has English translations
+  { locale: 'en', _id: '4', entityId: '3' },
+
+  // 4 only has German translations
+  { locale: 'de', _id: '5', entityId: '4' },
+];
+
+describe('buildLocaleMap', () => {
+  it('Mixed usage of default locale and forced languages', () => {
+    const queries = [
+      { locale: new Intl.Locale('de-CH') },
+      { locale: new Intl.Locale('fr') },
+      { locale: new Intl.Locale('it') },
+    ];
+    const expected = {
+      de: ['de-CH', 'fr', 'it'],
+      fr: ['fr'],
+      it: ['it'],
+    };
+    const result = buildLocaleMap(queries, testTexts);
+    assert.deepStrictEqual(result, expected);
+  });
+
+  it('Mixed usage of forced languages', () => {
+    const queries = [{ locale: new Intl.Locale('fr') }, { locale: new Intl.Locale('it') }];
+    const expected = {
+      de: ['fr', 'it'],
+      fr: ['fr'],
+      it: ['it'],
+    };
+    const result = buildLocaleMap(queries, testTexts);
+    assert.deepStrictEqual(result, expected);
+  });
+
+  it('Only default locale', () => {
+    const queries = [{ locale: new Intl.Locale('de-CH') }];
+    const expected = {
+      de: ['de-CH'],
+    };
+    const result = buildLocaleMap(queries, testTexts);
+    assert.deepStrictEqual(result, expected);
+  });
+
+  it('Only one forced language locale', () => {
+    const queries = [{ locale: new Intl.Locale('fr') }];
+    const expected = {
+      fr: ['fr'],
+      de: ['fr'],
+    };
+    const result = buildLocaleMap(queries, testTexts);
+    assert.deepStrictEqual(result, expected);
+  });
+});

package/src/loaders/buildLocaleMap.ts

@@ -0,0 +1,37 @@
+import { systemLocale } from '@unchainedshop/utils';
+
+function getLocaleStrings(locale: Intl.Locale): string[] {
+  try {
+    const locales = new Set<string>();
+    locales.add(locale.baseName);
+    locales.add(locale.language);
+    locales.add(systemLocale.baseName);
+    locales.add(systemLocale.language);
+    return Array.from(locales);
+  } catch {
+    // Optimized Set creation and spread
+    const locales = new Set<string>();
+    locales.add(systemLocale.baseName);
+    locales.add(systemLocale.language);
+    return Array.from(locales);
+  }
+}
+export default function buildLocaleMap(
+  queries: readonly { locale: Intl.Locale }[],
+  texts: readonly { locale?: string }[],
+): Record<string, string[]> {
+  // key = texts.locale
+  // value = input query locale
+  const queryLocales = new Set(queries.map((q) => q.locale));
+  const textLocales = new Set(texts.map((t) => t.locale));
+  const localeMap: Record<string, string[]> = {};
+  for (const queryLocale of queryLocales) {
+    const potentialMatches = getLocaleStrings(queryLocale);
+    const matches = potentialMatches.filter((l) => textLocales.has(l));
+    for (const match of matches) {
+      if (!localeMap[match]) localeMap[match] = [];
+      localeMap[match].push(queryLocale.toString());
+    }
+  }
+  return localeMap;
+}

package/src/loaders/buildTextMap.test.ts

@@ -0,0 +1,54 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import buildTextMap from './buildTextMap.js';
+
+const testTexts = [
+  // 1 has translations in French and German
+  { locale: 'fr', _id: 'french-1', entityId: '1' },
+  { locale: 'de', _id: 'german-1', entityId: '1' },
+
+  // 2 only has Ialien translations
+  { locale: 'it', _id: 'italian-2', entityId: '2' },
+
+  // 3 only has English translations
+  { locale: 'en', _id: 'english-3', entityId: '3' },
+
+  // 4 only has German translations
+  { locale: 'de', _id: 'german-4', entityId: '4' },
+];
+
+describe('buildTextMap', () => {
+  it('Generate a correct text map for all fallbacks', () => {
+    const localeMap = {
+      de: ['de-CH', 'fr', 'it'],
+      fr: ['fr'],
+      it: ['it'],
+    };
+    const expected = {
+      'de-CH1': {
+        _id: 'german-1',
+      },
+      fr1: {
+        _id: 'french-1',
+      },
+      it1: {
+        _id: 'german-1',
+      },
+      'de-CH4': {
+        _id: 'german-4',
+      },
+      fr4: {
+        _id: 'german-4',
+      },
+      it4: {
+        _id: 'german-4',
+      },
+      it2: {
+        _id: 'italian-2',
+      },
+    };
+    const result = buildTextMap(localeMap, testTexts, (text) => text.entityId);
+
+    assert.partialDeepStrictEqual(result, expected);
+  });
+});

package/src/loaders/buildTextMap.ts

@@ -1,17 +1,36 @@
 type ArrayElement<T> = T extends (infer U)[] ? U : never;
 
+/* This file has been optimized for performance to the last drop. Don't refactor! */
+
 export default function buildTextMap<T extends { locale?: string }[]>(
   localeMap: Record<string, string[]>,
   texts: Readonly<T>,
   buildId: (item: ArrayElement<T>) => string,
 ) {
-  const textsMap = {};
-  for (const [originLocale, localesForText] of Object.entries(localeMap)) {
-    for (const text of texts) {
+  const textsMap: Record<string, ArrayElement<T>> = {}; // Added type for textsMap
+  const localeMapKeys = Object.keys(localeMap);
+
+  // eslint-disable-next-line
+  for (let i = 0; i < localeMapKeys.length; i++) {
+    const originLocale = localeMapKeys[i];
+    const localesForText = localeMap[originLocale];
+
+    // eslint-disable-next-line
+    for (let j = 0; j < texts.length; j++) {
+      const text = texts[j];
       if (originLocale !== text.locale) continue;
-      for (const locale of localesForText) {
-        if (textsMap[locale + buildId(text as any)]) continue;
-        textsMap[locale + buildId(text as any)] = text;
+
+      const idPart = buildId(text as ArrayElement<T>); // Ensured correct type for buildId argument
+
+      // eslint-disable-next-line
+      for (let k = 0; k < localesForText.length; k++) {
+        const locale = localesForText[k];
+        const key = locale + idPart;
+        if (textsMap[key] && locale !== text.locale) {
+          // If the key already exists and the locale is a fallback, skip this text
+          continue;
+        }
+        textsMap[key] = text as ArrayElement<T>; // Ensured correct type for assignment
       }
     }
   }

package/src/loaders/filterTextLoader.ts

@@ -1,26 +1,27 @@
 import { UnchainedCore } from '@unchainedshop/core';
 import DataLoader from 'dataloader';
-import { buildLocaleMap } from './utils.js';
+import buildLocaleMap from './buildLocaleMap.js';
 import { FilterText } from '@unchainedshop/core-filters';
 import buildTextMap from './buildTextMap.js';
 
 export default (unchainedAPI: UnchainedCore) =>
-  new DataLoader<{ filterId: string; filterOptionValue?: string; locale: Intl.Locale }, FilterText>(
-    async (queries) => {
-      const filterIds = [...new Set(queries.map((q) => q.filterId).filter(Boolean))];
+  new DataLoader<
+    { filterId: string; filterOptionValue?: string | null; locale: Intl.Locale },
+    FilterText
+  >(async (queries) => {
+    const filterIds = [...new Set(queries.map((q) => q.filterId).filter(Boolean))];
 
-      const texts = await unchainedAPI.modules.filters.texts.findTexts(
-        { filterId: { $in: filterIds } },
-        {
-          sort: {
-            filterId: 1,
-          },
+    const texts = await unchainedAPI.modules.filters.texts.findTexts(
+      { filterId: { $in: filterIds } },
+      {
+        sort: {
+          filterId: 1,
         },
-      );
+      },
+    );
 
-      const localeMap = buildLocaleMap(queries, texts);
-      const textsMap = buildTextMap(localeMap, texts, (text) => text.filterId + text.filterOptionValue);
+    const localeMap = buildLocaleMap(queries, texts);
+    const textsMap = buildTextMap(localeMap, texts, (text) => text.filterId + text.filterOptionValue);
 
-      return queries.map((q) => textsMap[q.locale + q.filterId + q.filterOptionValue]);
-    },
-  );
+    return queries.map((q) => textsMap[q.locale + q.filterId + q.filterOptionValue]);
+  });

package/src/loaders/index.ts

@@ -14,6 +14,7 @@ import productLoaderBySKU from './productLoaderBySKU.js';
 import productTextLoader from './productTextLoader.js';
 import productMediaTextLoader from './productMediaTextLoader.js';
 import productMediasLoader from './productMediasLoader.js';
+import productProxiesLoader from './productProxiesLoader.js';
 import fileLoader from './fileLoader.js';
 import userLoader from './userLoader.js';
 import countryLoader from './countryLoader.js';
@@ -42,6 +43,7 @@ const loaders = (unchainedAPI: UnchainedCore) => {
     productTextLoader: productTextLoader(unchainedAPI),
     productMediaTextLoader: productMediaTextLoader(unchainedAPI),
     productMediasLoader: productMediasLoader(unchainedAPI),
+    productProxiesLoader: productProxiesLoader(unchainedAPI),
 
     fileLoader: fileLoader(unchainedAPI),
 

package/src/loaders/productMediaTextLoader.ts

@@ -1,7 +1,7 @@
 import { UnchainedCore } from '@unchainedshop/core';
 import DataLoader from 'dataloader';
-import { buildLocaleMap } from './utils.js';
 import { ProductMediaText } from '@unchainedshop/core-products';
+import buildLocaleMap from './buildLocaleMap.js';
 import buildTextMap from './buildTextMap.js';
 
 export default (unchainedAPI: UnchainedCore) =>

package/src/loaders/productMediasLoader.ts

@@ -3,7 +3,7 @@ import { ProductMedia } from '@unchainedshop/core-products';
 import DataLoader from 'dataloader';
 
 export default (unchainedAPI: UnchainedCore) =>
-  new DataLoader<{ productId?: string }, ProductMedia[]>(async (queries) => {
+  new DataLoader<{ productId: string }, ProductMedia[]>(async (queries) => {
     const productIds = [...new Set(queries.map((q) => q.productId).filter(Boolean))];
     const productMediaItems = await unchainedAPI.modules.products.media.findProductMedias({
       productId: { $in: productIds },

package/src/loaders/productProxiesLoader.ts

@@ -0,0 +1,37 @@
+import { UnchainedCore } from '@unchainedshop/core';
+import { Product } from '@unchainedshop/core-products';
+import DataLoader from 'dataloader';
+
+export default (unchainedAPI: UnchainedCore) =>
+  new DataLoader<{ productId: string }, Product[]>(async (queries) => {
+    const productIds = [...new Set(queries.map((q) => q.productId).filter(Boolean))];
+
+    const productProxies = await unchainedAPI.modules.products.findProducts({
+      includeDrafts: true,
+      productSelector: {
+        $or: [
+          {
+            'bundleItems.productId': { $in: productIds },
+          },
+          {
+            'proxy.assignments.productId': { $in: productIds },
+          },
+        ],
+      },
+    });
+
+    const productProxyMap = {};
+    for (const productProxy of productProxies) {
+      const bundleItemIds = productProxy.bundleItems?.map((item) => item.productId) || [];
+      const proxyAssignmentIds =
+        productProxy.proxy?.assignments?.map((assignment) => assignment.productId) || [];
+
+      for (const productId of [...bundleItemIds, ...proxyAssignmentIds]) {
+        if (!productProxyMap[productId]) {
+          productProxyMap[productId] = [];
+        }
+        productProxyMap[productId].push(productProxy);
+      }
+    }
+    return queries.map((q) => productProxyMap[q.productId] || []);
+  });

package/src/loaders/productTextLoader.ts

@@ -1,8 +1,8 @@
 import { UnchainedCore } from '@unchainedshop/core';
 import DataLoader from 'dataloader';
-import { buildLocaleMap } from './utils.js';
 import { ProductText } from '@unchainedshop/core-products';
 import buildTextMap from './buildTextMap.js';
+import buildLocaleMap from './buildLocaleMap.js';
 
 export default (unchainedAPI: UnchainedCore) =>
   new DataLoader<{ productId: string; locale: Intl.Locale }, ProductText>(async (queries) => {

package/src/loaders/utils.ts

@@ -21,7 +21,7 @@ export function buildLocaleMap(
     Object.fromEntries(queries.map((q) => [q.locale.baseName, q.locale])),
   );
 
-  const textLocales: string[] = [...new Set(texts.map((t) => t.locale))];
+  const textLocales = [...new Set(texts.map((t) => t.locale))].filter(Boolean) as string[];
   const localeMap = {};
   for (const queryLocale of queryLocales) {
     const potentialMatches = getLocaleStrings(queryLocale);

package/src/locale-context.ts

@@ -1,9 +1,4 @@
-import {
-  resolveBestCountry,
-  resolveBestSupported,
-  resolveBestCurrency,
-  systemLocale,
-} from '@unchainedshop/utils';
+import { resolveBestSupported, resolveBestCurrency } from '@unchainedshop/utils';
 import { UnchainedCore } from '@unchainedshop/core';
 import pMemoize from 'p-memoize';
 import ExpiryMap from 'expiry-map';
@@ -20,50 +15,48 @@ export type GetHeaderFn = (key: string) => string | string[];
 
 const memoizeCache = new ExpiryMap(process.env.NODE_ENV === 'production' ? 1000 * 60 : 1); // Cached values expire after 10 seconds
 
-export const resolveDefaultContext = pMemoize(
-  async ({ acceptLang, acceptCountry }, unchainedAPI) => {
-    const languages = await unchainedAPI.modules.languages.findLanguages(
-      { includeInactive: false },
-      { projection: { isoCode: 1, isActive: 1 } },
-    );
+const uncachedResolveDefaultContext = async (
+  { acceptLang, acceptCountry },
+  unchainedAPI: UnchainedCore,
+) => {
+  const languages = await unchainedAPI.modules.languages.findLanguages(
+    { includeInactive: false },
+    { projection: { isoCode: 1, isActive: 1 } },
+  );
 
-    const countries = await unchainedAPI.modules.countries.findCountries(
-      { includeInactive: false },
-      { projection: { isoCode: 1, isActive: 1 } },
-    );
+  const countries = await unchainedAPI.modules.countries.findCountries(
+    { includeInactive: false },
+    { projection: { isoCode: 1, isActive: 1 } },
+  );
 
-    const currencies = await unchainedAPI.modules.currencies.findCurrencies({ includeInactive: false });
+  const currencies = await unchainedAPI.modules.currencies.findCurrencies({ includeInactive: false });
 
-    const defaultCurrencyCodes = Object.fromEntries(
-      countries.map((c) => [c.isoCode, c.defaultCurrencyCode]),
-    );
+  const locale = resolveBestSupported(acceptLang, acceptCountry, { countries, languages });
 
-    const supportedLocaleStrings: string[] = languages.reduce((accumulator, language) => {
-      const added = countries.map((country) => {
-        return `${language.isoCode}-${country.isoCode}`;
-      });
-      return accumulator.concat(added);
-    }, []);
+  const defaultCurrencyCode = countries.find(
+    (country) => country.isoCode.toUpperCase() === locale?.region?.toUpperCase(),
+  )?.defaultCurrencyCode;
 
-    const locale = resolveBestSupported(acceptLang, supportedLocaleStrings, systemLocale.baseName);
-    const countryCode = resolveBestCountry(locale.region, acceptCountry, countries);
-    const currencyCode = resolveBestCurrency(defaultCurrencyCodes[countryCode], currencies);
+  const currencyCode = resolveBestCurrency(defaultCurrencyCode || null, currencies);
 
-    logger.debug(`Locale Context: Resolved ${locale.baseName} ${countryCode} ${currencyCode}`);
+  logger.debug(`Locale Context: Resolved ${locale?.baseName} ${currencyCode}`);
 
-    const newContext: UnchainedLocaleContext = {
-      locale,
-      countryCode,
-      currencyCode,
-    };
+  const newContext: UnchainedLocaleContext = {
+    locale,
+    countryCode: locale.region as string,
+    currencyCode,
+  };
 
-    return newContext;
-  },
-  {
-    cache: memoizeCache,
-    cacheKey: ([{ acceptLang, acceptCountry }]) => `${acceptLang}-${acceptCountry}`,
+  return newContext;
+};
+
+export const resolveDefaultContext = pMemoize(uncachedResolveDefaultContext, {
+  cache: memoizeCache,
+  cacheKey: (args) => {
+    const [{ acceptLang, acceptCountry }] = args;
+    return `${acceptLang}-${acceptCountry}`;
   },
-);
+});
 
 export const getLocaleContext = async (
   {

package/src/mcp/README.md

@@ -0,0 +1,25 @@
+# MCP Server
+
+This directory contains the Model Context Protocol (MCP) server implementation for Unchained Commerce.
+
+## Structure
+
+```
+mcp/
+├── index.ts              # Main MCP server setup
+├── types.ts              # Shared type definitions
+├── tools/                # Individual tool implementations
+│   ├── index.ts          # Re-exports for all tools
+│   └── listProducts.ts   # List products tool
+└── utils/                # Shared utilities
+    └── html.ts           # HTML generation utilities
+```
+
+## Adding New Tools
+
+To add a new tool:
+
+1. Create a new file in the `tools/` directory
+2. Export the schema and handler from the file
+3. Add the exports to `tools/index.ts`
+4. Register the tool in the main `index.ts` file

package/src/mcp/index.ts

@@ -0,0 +1,37 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { Context } from '../context.js';
+import { registerFilterTools } from './tools/filter/index.js';
+import { registerProductTools } from './tools/product/index.js';
+
+import { registerLocalizationTools } from './tools/localization/index.js';
+import { registerProviderTools } from './tools/provider/index.js';
+import { registerOrderTools } from './tools/order/index.js';
+import { registerQuotationTools } from './tools/quotation/index.js';
+import { registerAssortmentTools } from './tools/assortment/index.js';
+import { registerUsersTools } from './tools/users/index.js';
+import { registerSystemTools } from './tools/system/index.js';
+import { registerLocalizationResources } from './resources/localization.js';
+
+export default function createMcpServer(context: Context, roles) {
+  const server = new McpServer({
+    name: 'Unchained MCP Server',
+    version: '1.0.0',
+  });
+
+  if (!roles?.includes('admin')) {
+    return server;
+  }
+
+  registerLocalizationResources(server, context);
+
+  registerFilterTools(server, context);
+  registerProductTools(server, context);
+  registerAssortmentTools(server, context);
+  registerLocalizationTools(server, context);
+  registerSystemTools(server, context);
+  registerProviderTools(server, context);
+  registerOrderTools(server, context);
+  registerQuotationTools(server, context);
+  registerUsersTools(server, context);
+  return server;
+}