@unchainedshop/api 4.0.0-rc.3 → 4.0.0-rc.5

package/src/mcp/tools/filter/getFiltersHandler.ts

@@ -0,0 +1,54 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
+import { getNormalizedFilterDetails } from '../../utils/getNormalizedFilterDetails.js';
+
+const SortOptionInputSchema = z.object({
+  key: z.string().min(1).describe('Field key to sort by (e.g., "key", "createdAt")'),
+  value: z.enum(['ASC', 'DESC']).describe('Sort direction: ASC for ascending, DESC for descending'),
+});
+
+export const GetFiltersSchema = {
+  limit: z.number().min(1).max(100).default(20).describe('Maximum number of filters to return'),
+  offset: z.number().min(0).default(0).describe('Number of filters to skip (for pagination)'),
+  includeInactive: z.boolean().default(false).describe('Include inactive filters in the result'),
+  queryString: z.string().optional().describe('Free-text search filter (e.g., part of key or title)'),
+  sort: z.array(SortOptionInputSchema).optional().describe('List of sort options to order the filters'),
+};
+
+export const GetFiltersZodSchema = z.object(GetFiltersSchema);
+
+export type GetFiltersParams = z.infer<typeof GetFiltersZodSchema>;
+
+export async function getFiltersHandler(context: Context, params: GetFiltersParams) {
+  const { modules, userId } = context;
+
+  try {
+    log('handler getFiltersHandler', {
+      userId,
+      params,
+    });
+
+    const filters = await modules.filters.findFilters(params as any);
+    const normalizedFilters = await await Promise.all(
+      filters.map(async ({ _id }) => getNormalizedFilterDetails(_id, context)),
+    );
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ filters: normalizedFilters }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error fetching filters: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

package/src/mcp/tools/filter/index.ts

@@ -0,0 +1,74 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { Context } from '../../../context.js';
+import { createFilterHandler, CreateFilterSchema } from './createFilterHandler.js';
+import { updateFilterHandler, UpdateFilterSchema } from './updateFilterHandler.js';
+import { removeFilterHandler, RemoveFilterSchema } from './removeFilterHandler.js';
+import { createFilterOptionHandler, CreateFilterOptionSchema } from './createFilterOptionHandler.js';
+import { updateFilterTextsHandler, UpdateFilterTextsSchema } from './updateFilterTextsHandler.js';
+import { removeFilterOptionHandler, RemoveFilterOptionSchema } from './removeFilterOptionHandler.js';
+import { getFilterHandler, GetFilterSchema } from './getFilterHandler.js';
+import { getFiltersHandler, GetFiltersSchema } from './getFiltersHandler.js';
+import {
+  translatedFilterTextsHandler,
+  TranslatedFilterTextsSchema,
+} from './translatedFilterTextsHandler.js';
+
+export const registerFilterTools = (server: McpServer, context: Context) => {
+  server.tool(
+    'filter_create',
+    'Create a new product filter with optional localized titles and subtitles.',
+    CreateFilterSchema,
+    async (params) => createFilterHandler(context, params),
+  );
+  server.tool(
+    'filter_update',
+    'Update a filter by ID with optional changes to key or activation status.',
+    UpdateFilterSchema,
+    async (params) => updateFilterHandler(context, params),
+  );
+
+  server.tool(
+    'filter_remove',
+    'Remove a filter by its ID, including any associated assortment references.',
+    RemoveFilterSchema,
+    async (params) => removeFilterHandler(context, params),
+  );
+  server.tool(
+    'filter_option_create',
+    'Create a new option under a given filter with optional localized titles and subtitles.',
+    CreateFilterOptionSchema,
+    async (params) => createFilterOptionHandler(context, params),
+  );
+
+  server.tool(
+    'filter_updateTexts',
+    'Update localized texts for a filter or one of its options.',
+    UpdateFilterTextsSchema,
+    async (params) => updateFilterTextsHandler(context, params),
+  );
+
+  server.tool(
+    'filter_option_remove',
+    'Remove a specific option from a filter by its value.',
+    RemoveFilterOptionSchema,
+    async (params) => removeFilterOptionHandler(context, params),
+  );
+
+  server.tool('filter_get', 'Retrieve details of a filter by its ID.', GetFilterSchema, async (params) =>
+    getFilterHandler(context, params),
+  );
+
+  server.tool(
+    'filter_list',
+    'List filters with optional pagination, query string, and sorting. Can include inactive ones.',
+    GetFiltersSchema,
+    async (params) => getFiltersHandler(context, params),
+  );
+
+  server.tool(
+    'filter_getTexts',
+    'Retrieve translated texts for a filter or a specific filter option.',
+    TranslatedFilterTextsSchema,
+    async (params) => translatedFilterTextsHandler(context, params),
+  );
+};

package/src/mcp/tools/filter/removeFilterHandler.ts

@@ -0,0 +1,45 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
+import { FilterNotFoundError } from '../../../errors.js';
+import { getNormalizedFilterDetails } from '../../utils/getNormalizedFilterDetails.js';
+
+export const RemoveFilterSchema = {
+  filterId: z.string().min(1).describe('Unique identifier of the filter to be removed'),
+};
+
+export const RemoveFilterZodSchema = z.object(RemoveFilterSchema);
+
+export type RemoveFilterParams = z.infer<typeof RemoveFilterZodSchema>;
+
+export async function removeFilterHandler(context: Context, params: RemoveFilterParams) {
+  const { filterId } = params;
+  const { modules, userId } = context;
+
+  try {
+    log(`handler removeFilterHandler`, { userId, params });
+
+    const filter = await getNormalizedFilterDetails(filterId, context);
+    if (!filter) throw new FilterNotFoundError({ filterId });
+
+    await modules.assortments.filters.deleteMany({ filterId });
+    await modules.filters.delete(filterId);
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ filter }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error removing filter: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

package/src/mcp/tools/filter/removeFilterOptionHandler.ts

@@ -0,0 +1,50 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
+import { FilterNotFoundError } from '../../../errors.js';
+import { getNormalizedFilterDetails } from '../../utils/getNormalizedFilterDetails.js';
+import { FilterDirector } from '@unchainedshop/core';
+
+export const RemoveFilterOptionSchema = {
+  filterId: z.string().min(1).describe('Unique identifier of the filter to modify'),
+  filterOptionValue: z.string().min(1).describe('Exact value of the filter option to remove'),
+};
+
+export const RemoveFilterOptionZodSchema = z.object(RemoveFilterOptionSchema);
+
+export type RemoveFilterOptionParams = z.infer<typeof RemoveFilterOptionZodSchema>;
+
+export async function removeFilterOptionHandler(context: Context, params: RemoveFilterOptionParams) {
+  const { filterId, filterOptionValue } = params;
+  const { modules, userId } = context;
+
+  try {
+    log('handler removeFilterOptionHandler', { userId, params });
+    const filter = await getNormalizedFilterDetails(filterId, context);
+    if (!filter) throw new FilterNotFoundError({ filterId });
+
+    const removedFilterOption = await modules.filters.removeFilterOption({
+      filterId,
+      filterOptionValue,
+    });
+    await FilterDirector.invalidateProductIdCache(removedFilterOption, context);
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ filter }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error removing filter option: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

package/src/mcp/tools/filter/translatedFilterTextsHandler.ts

@@ -0,0 +1,59 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
+import { FilterNotFoundError } from '../../../errors.js';
+
+export const TranslatedFilterTextsSchema = {
+  filterId: z
+    .string()
+    .min(1)
+    .describe('Unique identifier of the filter to retrieve translated texts for'),
+  filterOptionValue: z
+    .string()
+    .optional()
+    .describe('Optional: specific filter option value to fetch translated texts for'),
+};
+
+export const TranslatedFilterTextsZodSchema = z.object(TranslatedFilterTextsSchema);
+
+export type TranslatedFilterTextsParams = z.infer<typeof TranslatedFilterTextsZodSchema>;
+
+export async function translatedFilterTextsHandler(
+  context: Context,
+  params: TranslatedFilterTextsParams,
+) {
+  const { filterId, filterOptionValue } = params;
+  const { modules, userId } = context;
+
+  try {
+    log('handler translatedFilterTextsHandler', { userId, params });
+
+    const filter = await modules.filters.findFilter({ filterId });
+    if (!filter) {
+      throw new FilterNotFoundError({ filterId });
+    }
+
+    const texts = await modules.filters.texts.findTexts({
+      filterId,
+      filterOptionValue: filterOptionValue || null,
+    });
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ texts }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error retrieving filter texts: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

package/src/mcp/tools/filter/updateFilterHandler.ts

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
+import { FilterNotFoundError } from '../../../errors.js';
+import { FilterDirector } from '@unchainedshop/core';
+import { getNormalizedFilterDetails } from '../../utils/getNormalizedFilterDetails.js';
+
+export const UpdateFilterInputSchema = z.object({
+  isActive: z.boolean().optional().describe('Whether the filter should be active or not'),
+  key: z.string().min(1).optional().describe('New unique key for the filter (if updating)'),
+});
+
+export const UpdateFilterSchema = {
+  filterId: z.string().min(1).describe('ID of the filter to update'),
+  filter: UpdateFilterInputSchema.describe('Filter fields to update'),
+};
+
+export const UpdateFilterZodSchema = z.object(UpdateFilterSchema);
+
+export type UpdateFilterParams = z.infer<typeof UpdateFilterZodSchema>;
+
+export async function updateFilterHandler(context: Context, params: UpdateFilterParams) {
+  const { filterId, filter } = params;
+  const { modules, userId } = context;
+
+  try {
+    log('handler updateFilterHandler', { userId, params });
+    if (!(await modules.filters.filterExists({ filterId }))) throw new FilterNotFoundError({ filterId });
+
+    const updatedFilter = await modules.filters.update(filterId, filter as any);
+    await FilterDirector.invalidateProductIdCache(updatedFilter, context);
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ filter: await getNormalizedFilterDetails(filterId, context) }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error updating filter: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

package/src/mcp/tools/filter/updateFilterTextsHandler.ts

@@ -0,0 +1,63 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
+import { FilterNotFoundError } from '../../../errors.js';
+import { getNormalizedFilterDetails } from '../../utils/getNormalizedFilterDetails.js';
+
+export const FilterUpdateTextInputSchema = z.object({
+  locale: z.string().min(1).describe('Locale ISO code (e.g., "en-US", "de-CH")'),
+  title: z.string().optional().describe('Title for the filter or filter option in the specified locale'),
+  subtitle: z
+    .string()
+    .optional()
+    .describe('Subtitle for the filter or filter option in the specified locale'),
+});
+
+export const UpdateFilterTextsSchema = {
+  filterId: z.string().min(1).describe('ID of the filter to update localized texts for'),
+  filterOptionValue: z
+    .string()
+    .optional()
+    .describe('Optional value of the filter option to localize (if applicable)'),
+  texts: z
+    .array(FilterUpdateTextInputSchema)
+    .min(1)
+    .describe('Array of localized texts to set or update'),
+};
+
+export const UpdateFilterTextsZodSchema = z.object(UpdateFilterTextsSchema);
+
+export type UpdateFilterTextsParams = z.infer<typeof UpdateFilterTextsZodSchema>;
+
+// Handler
+export async function updateFilterTextsHandler(context: Context, params: UpdateFilterTextsParams) {
+  const { filterId, filterOptionValue, texts } = params;
+  const { modules, userId } = context;
+
+  try {
+    log('handler updateFilterTexts', { userId, filterId, filterOptionValue, texts });
+
+    const filter = await getNormalizedFilterDetails(filterId, context);
+    if (!filter) throw new FilterNotFoundError({ filterId });
+
+    const updatedTexts = await modules.filters.texts.updateTexts({ filterId, filterOptionValue }, texts);
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ filterTexts: updatedTexts }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error updating filter texts: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

package/src/mcp/tools/index.ts

@@ -1,39 +1,12 @@
-/**
- * Re-export all MCP tools
- */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { Context } from '../../context.js';
+import { shopInfoHandler } from './shopInfoHandler.js';
 
-export * from './listProducts.js';
-export * from './getProduct.js';
-export * from './createProduct.js';
-export * from './removeProductHandler.js';
-export * from './publishProduct.js';
-export * from './unPublishProduct.js';
-export * from './updateProduct.js';
-export * from './updateProductTextsHandler.js';
-export * from './updateProductCommerceHandler.js';
-export * from './updateProductSupplyHandler.js';
-export * from './updateProductWarehousingHandler.js';
-export * from './currenciesHandler.js';
-export * from './currencyHandler.js';
-export * from './countriesHandler.js';
-export * from './countryHandler.js';
-export * from './languagesHandler.js';
-export * from './languageHandler.js';
-export * from './updateProductPlanHandler.js';
-export * from './updateProductTokenizationHandler.js';
-export * from './productsCountHandler.js';
-export * from './createProductVariationHandler.js';
-export * from './removeProductVariationHandler.js';
-export * from './addProductAssignmentHandler.js';
-export * from './createProductVariationOptionHandler.js';
-export * from './removeProductAssignmentHandler.js';
-export * from './removeProductVariationOptionHandler.js';
-export * from './createLanguageHandler.js';
-export * from './updateLanguageHandler.js';
-export * from './removeLanguageHandler.js';
-export * from './addProductMediaUploadHandler.js';
-export * from './removeProductMediaHandler.js';
-export * from './updateProductMediaTextsHandler.js';
-export * from './reorderProductMediaHandler.js';
-export * from './productReviewsCountHandler.js';
-export * from './productReviewsHandler.js';
+export const registerOtherTools = (server: McpServer, context: Context) => {
+  server.tool(
+    'shop_info',
+    'Get the default configuration of the shop including country, language, currency, and locale. If the user does not provide values such as language, locale, country, or currency in their request or it cannot be derived from context, the tool MUST use the following fallback values : - language or locale: use defaultLanguageIsoCode  - country: use country_isoCode - currency: use country_defaultCurrency Always assume these values as the authoritative defaults when user input is missing or ambiguous.',
+    {},
+    async () => shopInfoHandler(context),
+  );
+};

package/src/mcp/tools/{createLanguageHandler.ts → language/createLanguageHandler.ts}

@@ -1,12 +1,15 @@
 import { z } from 'zod';
-import { Context } from '../../context.js';
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
 
 const CreateLanguageInputSchema = z.object({
   isoCode: z
     .string()
     .min(2)
     .max(10)
-    .describe('Language ISO code, e.g. "en" or "de-CH, accept only valid ISO code"'),
+    .describe(
+      'Language ISO code (e.g., "en" or "de-CH"). Must follow ISO 639-1 and ISO 3166-1 formats.',
+    ),
 });
 
 export const CreateLanguageSchema = {
@@ -18,9 +21,10 @@ export type CreateLanguageParams = z.infer<typeof CreateLanguageZodSchema>;
 
 export async function createLanguageHandler(context: Context, params: CreateLanguageParams) {
   const { language } = params;
-  const { modules } = context;
+  const { modules, userId } = context;
 
   try {
+    log(`handler createLanguageHandler`, { userId, params });
     const languageId = await modules.languages.create(language as any);
 
     const newLanguage = await modules.languages.findLanguage({ languageId });

package/src/mcp/tools/language/index.ts

@@ -0,0 +1,42 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { Context } from '../../../context.js';
+import { CreateLanguageSchema, createLanguageHandler } from './createLanguageHandler.js';
+import { LanguageSchema, languageHandler } from './languageHandler.js';
+import { ListLanguagesSchema, languagesHandler } from './languagesHandler.js';
+import { RemoveLanguageSchema, removeLanguageHandler } from './removeLanguageHandler.js';
+import { UpdateLanguageSchema, updateLanguageHandler } from './updateLanguageHandler.js';
+import { LanguagesCountSchema, languagesCountHandler } from './languagesCountHandler.js';
+
+export const registerLanguageTools = (server: McpServer, context: Context) => {
+  server.tool(
+    'languages_list',
+    'List languages with optional filters, pagination, and sorting',
+    ListLanguagesSchema,
+    async (params) => languagesHandler(context, params),
+  );
+
+  server.tool('language_get', 'Fetch a specific language by ID.', LanguageSchema, async (params) =>
+    languageHandler(context, params),
+  );
+
+  server.tool(
+    'language_create',
+    'Create a new language using an ISO code like "en" or "de-CH".',
+    CreateLanguageSchema,
+    async (params) => createLanguageHandler(context, params),
+  );
+
+  server.tool('update_language', 'Update language details', UpdateLanguageSchema, async (params) =>
+    updateLanguageHandler(context, params),
+  );
+
+  server.tool('language_remove', 'Remove a language by its ID', RemoveLanguageSchema, async (params) =>
+    removeLanguageHandler(context, params),
+  );
+  server.tool(
+    'language_count',
+    'Return the count of languages, optionally including inactive and filtering by search text.',
+    LanguagesCountSchema,
+    async (params) => languagesCountHandler(context, params),
+  );
+};

package/src/mcp/tools/{languageHandler.ts → language/languageHandler.ts}

@@ -1,5 +1,6 @@
 import { z } from 'zod';
-import { Context } from '../../context.js';
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
 
 export const LanguageSchema = {
   languageId: z.string().min(1).describe('The ID of the language to fetch'),
@@ -11,9 +12,10 @@ export type LanguageParams = z.infer<typeof LanguageZodSchema>;
 
 export async function languageHandler(context: Context, params: LanguageParams) {
   const { languageId } = params;
-  const { modules } = context;
+  const { modules, userId } = context;
 
   try {
+    log(`handler languageHandler`, { userId, params });
     const language = await modules.languages.findLanguage({ languageId });
 
     return {

package/src/mcp/tools/language/languagesCountHandler.ts

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
+
+export const LanguagesCountSchema = {
+  includeInactive: z.boolean().optional().default(false).describe('Include inactive languages in count'),
+  queryString: z.string().optional().describe('Optional search filter'),
+};
+
+export const LanguagesCountZodSchema = z.object(LanguagesCountSchema);
+
+export type LanguagesCountParams = z.infer<typeof LanguagesCountZodSchema>;
+
+export async function languagesCountHandler(context: Context, params: LanguagesCountParams) {
+  const { modules, userId } = context;
+
+  try {
+    log(`handler languagesCountHandler `, {
+      userId,
+      params,
+    });
+
+    const count = await modules.languages.count(params);
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify(count),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error counting languages: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

package/src/mcp/tools/{languagesHandler.ts → language/languagesHandler.ts}

@@ -1,6 +1,7 @@
 import { z } from 'zod';
-import { Context } from '../../context.js';
+import { Context } from '../../../context.js';
 import { SortDirection } from '@unchainedshop/utils';
+import { log } from '@unchainedshop/logger';
 
 const sortDirectionKeys = Object.keys(SortDirection) as [
   keyof typeof SortDirection,
@@ -8,18 +9,19 @@ const sortDirectionKeys = Object.keys(SortDirection) as [
 ];
 
 export const ListLanguagesSchema = {
-  limit: z.number().int().min(1).max(100).default(50),
-  offset: z.number().int().min(0).default(0),
-  includeInactive: z.boolean().default(false),
-  queryString: z.string().min(1).optional(),
+  limit: z.number().int().min(1).max(100).default(50).describe('Maximum number of languages to return'),
+  offset: z.number().int().min(0).default(0).describe('Number of languages to skip for pagination'),
+  includeInactive: z.boolean().default(false).describe('Whether to include inactive languages'),
+  query_string: z.string().min(1).optional().describe('Optional text search filter'),
   sort: z
     .array(
       z.object({
-        key: z.string().min(1),
-        value: z.enum(sortDirectionKeys).describe("Sort direction, e.g., 'ASC' or 'DESC'"),
+        key: z.string().min(1).describe('Field to sort by'),
+        value: z.enum(sortDirectionKeys).describe("Sort direction, 'ASC' or 'DESC'"),
       }),
     )
-    .optional(),
+    .optional()
+    .describe('Sort configuration'),
 };
 
 export const ListLanguagesZodSchema = z.object(ListLanguagesSchema);
@@ -27,11 +29,14 @@ export const ListLanguagesZodSchema = z.object(ListLanguagesSchema);
 export type ListLanguagesParams = z.infer<typeof ListLanguagesZodSchema>;
 
 export async function languagesHandler(context: Context, params: ListLanguagesParams) {
-  const { sort, ...restParams } = params;
-  const { modules } = context;
+  const { modules, userId } = context;
 
   try {
-    const languages = await modules.languages.findLanguages({ ...restParams, sort: sort as any[] });
+    log(`handler languagesHandler `, {
+      userId,
+      params,
+    });
+    const languages = await modules.languages.findLanguages(params as any);
 
     return {
       content: [

package/src/mcp/tools/{removeLanguageHandler.ts → language/removeLanguageHandler.ts}

@@ -1,6 +1,7 @@
 import { z } from 'zod';
-import { Context } from '../../context.js';
-import { LanguageNotFoundError } from '../../errors.js';
+import { Context } from '../../../context.js';
+import { LanguageNotFoundError } from '../../../errors.js';
+import { log } from '@unchainedshop/logger';
 
 export const RemoveLanguageSchema = {
   languageId: z.string().min(1).describe('ID of the language to remove'),
@@ -11,9 +12,13 @@ export type RemoveLanguageParams = z.infer<typeof RemoveLanguageZodSchema>;
 
 export async function removeLanguageHandler(context: Context, params: RemoveLanguageParams) {
   const { languageId } = params;
-  const { modules } = context;
+  const { modules, userId } = context;
 
   try {
+    log(`handler languagesHandler `, {
+      userId,
+      params,
+    });
     if (!(await modules.languages.languageExists({ languageId })))
       throw new LanguageNotFoundError({ languageId });