@unchainedshop/api 4.0.0-rc.9 → 4.0.1

package/src/mcp/tools/assortment/reorderAssortmentProductsHandler.ts

@@ -1,53 +0,0 @@
-import { z } from 'zod';
-import { Context } from '../../../context.js';
-import { log } from '@unchainedshop/logger';
-
-export const ReorderAssortmentProductInputSchema = z.object({
-  assortmentProductId: z.string().min(1).describe('ID of the assortment product to reorder'),
-  sortKey: z.number().describe('New sorting key for the product'),
-});
-
-export const ReorderAssortmentProductsSchema = {
-  sortKeys: z
-    .array(ReorderAssortmentProductInputSchema)
-    .min(1)
-    .describe('Array of assortmentProductId with their new sort keys'),
-};
-
-export const ReorderAssortmentProductsZodSchema = z.object(ReorderAssortmentProductsSchema);
-
-export type ReorderAssortmentProductsParams = z.infer<typeof ReorderAssortmentProductsZodSchema>;
-
-export async function reorderAssortmentProductsHandler(
-  context: Context,
-  params: ReorderAssortmentProductsParams,
-) {
-  const { sortKeys } = params;
-  const { modules, userId } = context;
-
-  try {
-    log('handler reorderAssortmentProductsHandler', { userId, params });
-
-    await modules.assortments.products.updateManualOrder({
-      sortKeys,
-    } as any);
-
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: JSON.stringify({ success: true }),
-        },
-      ],
-    };
-  } catch (error) {
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: `Error reordering assortment products: ${(error as Error).message}`,
-        },
-      ],
-    };
-  }
-}

package/src/mcp/tools/assortment/searchAssortmentProductHandler.ts

@@ -1,100 +0,0 @@
-import { z } from 'zod';
-import { Context } from '../../../context.js';
-import { log } from '@unchainedshop/logger';
-
-export const SearchAssortmentProductSchema = {
-  assortmentId: z.string().min(1).describe('ID of the assortment to search in'),
-  queryString: z.string().optional().describe('Search query string'),
-  filterQuery: z
-    .array(
-      z.object({
-        key: z.string().describe('Filter key'),
-        value: z.string().optional().describe('Optional filter value'),
-      }),
-    )
-    .optional()
-    .describe('Filter conditions'),
-  includeInactive: z
-    .boolean()
-    .optional()
-    .default(true)
-    .describe('Whether to include inactive products in search results'),
-  ignoreChildAssortments: z
-    .boolean()
-    .optional()
-    .default(false)
-    .describe('Whether to ignore child assortments during search'),
-  limit: z.number().int().min(1).max(100).default(20).describe('Pagination limit'),
-  offset: z.number().int().min(0).default(0).describe('Pagination offset'),
-};
-
-export const SearchAssortmentProductZodSchema = z.object(SearchAssortmentProductSchema);
-
-export type SearchAssortmentProductParams = z.infer<typeof SearchAssortmentProductZodSchema>;
-
-export async function searchAssortmentProductHandler(
-  context: Context,
-  params: SearchAssortmentProductParams,
-) {
-  const { userId, modules, services, locale } = context;
-  const { assortmentId, limit, offset, ...query } = params;
-
-  try {
-    log('handler searchAssortmentProductHandler', { userId, params });
-
-    const productIds = await modules.assortments.findProductIds({
-      assortmentId,
-      ignoreChildAssortments: query.ignoreChildAssortments,
-    });
-
-    const filterIds = await modules.assortments.filters.findFilterIds({
-      assortmentId,
-    });
-    const result = await services.filters.searchProducts({ ...query, productIds, filterIds } as any, {
-      locale: locale,
-    });
-    const productsCount = await modules.products.search.countFilteredProducts({
-      productSelector: result.searchConfiguration.productSelector,
-      productIds: result.aggregatedTotalProductIds,
-    });
-    const products = await modules.products.search.findFilteredProducts({
-      limit,
-      offset,
-      productIds: result.aggregatedFilteredProductIds,
-      productSelector: result.searchConfiguration.productSelector,
-      sort: result.searchConfiguration.sortStage,
-    });
-
-    const relevantProductIds = await modules.products.findProductIds({
-      productSelector: result.searchConfiguration.productSelector,
-      productIds: result.totalProductIds,
-      includeDrafts: result.searchConfiguration.searchQuery.includeInactive,
-    });
-    const filters = await services.filters.loadFilters(result.searchConfiguration.searchQuery, {
-      productIds: relevantProductIds,
-      forceLiveCollection: result.searchConfiguration.forceLiveCollection,
-    });
-    const filteredProductsCount = await modules.products.search.countFilteredProducts({
-      productSelector: result.searchConfiguration.productSelector,
-      productIds: result.aggregatedFilteredProductIds,
-    });
-
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: JSON.stringify({ productsCount, products, filters, filteredProductsCount }),
-        },
-      ],
-    };
-  } catch (error) {
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: `Error searching products: ${(error as Error).message}`,
-        },
-      ],
-    };
-  }
-}

package/src/mcp/tools/assortment/setBaseAssortmentHandler.ts

@@ -1,46 +0,0 @@
-import { z } from 'zod';
-import { Context } from '../../../context.js';
-import { log } from '@unchainedshop/logger';
-import { getNormalizedAssortmentDetails } from '../../utils/getNormalizedAssortmentDetails.js';
-import { AssortmentNotFoundError } from '../../../errors.js';
-
-export const SetBaseAssortmentSchema = {
-  assortmentId: z.string().min(1).describe('ID of the assortment to set as base'),
-};
-
-export const SetBaseAssortmentZodSchema = z.object(SetBaseAssortmentSchema);
-export type SetBaseAssortmentParams = z.infer<typeof SetBaseAssortmentZodSchema>;
-
-export async function setBaseAssortmentHandler(context: Context, params: SetBaseAssortmentParams) {
-  const { modules, userId } = context;
-  const { assortmentId } = params;
-
-  try {
-    log('handler setBaseAssortmentHandler', { userId, params });
-
-    if (!(await modules.assortments.assortmentExists({ assortmentId })))
-      throw new AssortmentNotFoundError({ assortmentId });
-
-    await modules.assortments.setBase(assortmentId);
-
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: JSON.stringify({
-            assortment: await getNormalizedAssortmentDetails({ assortmentId }, context),
-          }),
-        },
-      ],
-    };
-  } catch (error) {
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: `Error setting base assortment: ${(error as Error).message}`,
-        },
-      ],
-    };
-  }
-}

package/src/mcp/tools/assortment/translatedAssortmentMediaTextsHandler.ts

@@ -1,54 +0,0 @@
-import { z } from 'zod';
-import { Context } from '../../../context.js';
-import { log } from '@unchainedshop/logger';
-import { AssortmentMediaNotFoundError } from '../../../errors.js';
-
-export const TranslatedAssortmentMediaTextsSchema = {
-  assortmentMediaId: z.string().min(1).describe('ID of the assortment media to retrieve texts for'),
-};
-
-export const TranslatedAssortmentMediaTextsZodSchema = z.object(TranslatedAssortmentMediaTextsSchema);
-
-export type TranslatedAssortmentMediaTextsParams = z.infer<
-  typeof TranslatedAssortmentMediaTextsZodSchema
->;
-
-export async function translatedAssortmentMediaTextsHandler(
-  context: Context,
-  params: TranslatedAssortmentMediaTextsParams,
-) {
-  const { assortmentMediaId } = params;
-  const { modules, userId } = context;
-
-  try {
-    log('handler translatedAssortmentMediaTextsHandler', { userId, params });
-
-    const assortmentMedia = await modules.assortments.media.findAssortmentMedia({
-      assortmentMediaId,
-    });
-
-    if (!assortmentMedia) throw new AssortmentMediaNotFoundError({ assortmentMediaId });
-
-    const texts = await modules.assortments.media.texts.findMediaTexts({
-      assortmentMediaId,
-    });
-
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: JSON.stringify({ texts, assortmentId: assortmentMedia.assortmentId }),
-        },
-      ],
-    };
-  } catch (error) {
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: `Error retrieving assortment media texts: ${(error as Error).message}`,
-        },
-      ],
-    };
-  }
-}

package/src/mcp/tools/assortment/translatedAssortmentTextsHandler.ts

@@ -1,43 +0,0 @@
-import { z } from 'zod';
-import { Context } from '../../../context.js';
-import { log } from '@unchainedshop/logger';
-
-export const TranslatedAssortmentTextsSchema = {
-  assortmentId: z.string().min(1).describe('ID of the assortment to retrieve texts for'),
-};
-
-export const TranslatedAssortmentTextsZodSchema = z.object(TranslatedAssortmentTextsSchema);
-
-export type TranslatedAssortmentTextsParams = z.infer<typeof TranslatedAssortmentTextsZodSchema>;
-
-export async function translatedAssortmentTextsHandler(
-  context: Context,
-  params: TranslatedAssortmentTextsParams,
-) {
-  const { assortmentId } = params;
-  const { modules, userId } = context;
-
-  try {
-    log('handler translatedAssortmentTextsHandler', { userId, params });
-
-    const texts = await modules.assortments.texts.findTexts({ assortmentId });
-
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: JSON.stringify({ texts }),
-        },
-      ],
-    };
-  } catch (error) {
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: `Error retrieving assortment texts: ${(error as Error).message}`,
-        },
-      ],
-    };
-  }
-}

package/src/mcp/tools/assortment/updateAssortmentHandler.ts

@@ -1,64 +0,0 @@
-import { z } from 'zod';
-import { Context } from '../../../context.js';
-import { log } from '@unchainedshop/logger';
-import { AssortmentNotFoundError } from '../../../errors.js';
-import { getNormalizedAssortmentDetails } from '../../utils/getNormalizedAssortmentDetails.js';
-
-export const UpdateAssortmentInputSchema = z.object({
-  isRoot: z
-    .boolean()
-    .optional()
-    .describe('If true, sets this assortment as a root assortment (top-level).'),
-  isActive: z.boolean().optional().describe('Whether this assortment is active'),
-  sequence: z
-    .number()
-    .int()
-    .optional()
-    .describe('Order of the assortment in a sorted list (lower number = higher priority).'),
-  tags: z
-    .array(z.string().min(1).toLowerCase())
-    .optional()
-    .describe('Tags (lowercase) used to categorize or filter the assortment.'),
-});
-
-export const UpdateAssortmentSchema = {
-  assortmentId: z.string().min(1).describe('ID of the assortment to update'),
-  assortment: UpdateAssortmentInputSchema.describe('Partial object with fields to update.'),
-};
-
-export const UpdateAssortmentZodSchema = z.object(UpdateAssortmentSchema);
-export type UpdateAssortmentParams = z.infer<typeof UpdateAssortmentZodSchema>;
-
-export async function updateAssortmentHandler(context: Context, params: UpdateAssortmentParams) {
-  const { modules, userId } = context;
-  const { assortmentId, assortment } = params;
-
-  try {
-    log('handler updateAssortmentHandler', { userId, params });
-
-    if (!(await modules.assortments.assortmentExists({ assortmentId })))
-      throw new AssortmentNotFoundError({ assortmentId });
-
-    await modules.assortments.update(assortmentId, assortment as any);
-    const updatedAssortment = await getNormalizedAssortmentDetails({ assortmentId }, context);
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: JSON.stringify({
-            assortment: updatedAssortment,
-          }),
-        },
-      ],
-    };
-  } catch (error) {
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: `Error updating assortment: ${(error as Error).message}`,
-        },
-      ],
-    };
-  }
-}

package/src/mcp/tools/assortment/updateAssortmentMediaTextsHandler.ts

@@ -1,67 +0,0 @@
-import { z } from 'zod';
-import { Context } from '../../../context.js';
-import { log } from '@unchainedshop/logger';
-import { AssortmentMediaNotFoundError } from '../../../errors.js';
-
-export const AssortmentMediaTextInputSchema = z.object({
-  locale: z
-    .string()
-    .min(2)
-    .describe(
-      'locale iso code like "en-US", "de-CH" use default defaultLanguageIsoCode in shop info if not explicitly provided. if language is explicitly provided check if it exists',
-    ),
-  title: z.string().optional().describe('Title in the given locale'),
-  subtitle: z.string().optional().describe('Subtitle in the given locale'),
-});
-
-export const UpdateAssortmentMediaTextsSchema = {
-  assortmentMediaId: z.string().min(1).describe('ID of the assortment media to update'),
-  texts: z.array(AssortmentMediaTextInputSchema).min(1).describe('Localized text values to update'),
-};
-
-export const UpdateAssortmentMediaTextsZodSchema = z.object(UpdateAssortmentMediaTextsSchema);
-
-export type UpdateAssortmentMediaTextsParams = z.infer<typeof UpdateAssortmentMediaTextsZodSchema>;
-
-export async function updateAssortmentMediaTextsHandler(
-  context: Context,
-  params: UpdateAssortmentMediaTextsParams,
-) {
-  const { assortmentMediaId, texts } = params;
-  const { modules, userId } = context;
-
-  try {
-    log('handler updateAssortmentMediaTextsHandler', { userId, params });
-
-    const assortmentMedia = await modules.assortments.media.findAssortmentMedia({
-      assortmentMediaId,
-    });
-
-    if (!assortmentMedia) throw new AssortmentMediaNotFoundError({ assortmentMediaId });
-
-    const assortmentMediaTexts = await modules.assortments.media.texts.updateMediaTexts(
-      assortmentMediaId,
-      texts,
-    );
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: JSON.stringify({
-            texts: assortmentMediaTexts,
-            assortmentId: assortmentMedia?.assortmentId,
-          }),
-        },
-      ],
-    };
-  } catch (error) {
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: `Error updating assortment media texts: ${(error as Error).message}`,
-        },
-      ],
-    };
-  }
-}

package/src/mcp/tools/assortment/updateAssortmentTextsHandler.ts

@@ -1,66 +0,0 @@
-import { z } from 'zod';
-import { Context } from '../../../context.js';
-import { log } from '@unchainedshop/logger';
-import { AssortmentNotFoundError } from '../../../errors.js';
-
-export const AssortmentAssortmentTextInputSchema = z.object({
-  locale: z
-    .string()
-    .min(2)
-    .describe(
-      `Locale ISO code for the language of the text (e.g., "en-US", "de-CH").
-If not provided, fallback to the shop's defaultLanguageIsoCode.
-If provided, it must be a valid language configured in the shop.`,
-    ),
-  slug: z
-    .string()
-    .optional()
-    .describe('Optional URL-safe identifier for the assortment (e.g., "summer-sale").'),
-  title: z.string().optional().describe('Optional title for the assortment in this locale.'),
-  subtitle: z.string().optional().describe('Optional subtitle providing extra context.'),
-  description: z.string().optional().describe('Optional long-form description of the assortment.'),
-});
-
-export const UpdateAssortmentTextsSchema = {
-  assortmentId: z.string().min(1).describe('ID of the assortment to update'),
-  texts: z.array(AssortmentAssortmentTextInputSchema).min(1).describe('Localized metadata to update'),
-};
-
-export const UpdateAssortmentTextsZodSchema = z.object(UpdateAssortmentTextsSchema);
-
-export type UpdateAssortmentTextsParams = z.infer<typeof UpdateAssortmentTextsZodSchema>;
-
-export async function updateAssortmentTextsHandler(
-  context: Context,
-  params: UpdateAssortmentTextsParams,
-) {
-  const { assortmentId, texts } = params;
-  const { modules, userId } = context;
-
-  try {
-    log('handler updateAssortmentTextsHandler', { userId, params });
-
-    if (!(await modules.assortments.assortmentExists({ assortmentId })))
-      throw new AssortmentNotFoundError({ assortmentId });
-
-    const assortmentTexts = await modules.assortments.texts.updateTexts(assortmentId, texts as any);
-
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: JSON.stringify({ texts: assortmentTexts }),
-        },
-      ],
-    };
-  } catch (error) {
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: `Error updating assortment texts: ${(error as Error).message}`,
-        },
-      ],
-    };
-  }
-}

package/src/mcp/tools/country/countriesCountHandler.ts

@@ -1,50 +0,0 @@
-import { z } from 'zod';
-import { Context } from '../../../context.js';
-import { log } from '@unchainedshop/logger';
-
-export const CountriesCountSchema = {
-  includeInactive: z
-    .boolean()
-    .optional()
-    .default(false)
-    .describe('If true, include inactive countries in the count. Defaults to false.'),
-  queryString: z
-    .string()
-    .optional()
-    .describe('Optional search string to filter countries by name or code'),
-};
-
-export const CountriesCountZodSchema = z.object(CountriesCountSchema);
-
-export type CountriesCountParams = z.infer<typeof CountriesCountZodSchema>;
-
-export async function countriesCountHandler(context: Context, params: CountriesCountParams) {
-  const { modules, userId } = context;
-
-  try {
-    log(`handler countriesCountHandler`, {
-      userId,
-      params,
-    });
-
-    const count = await modules.countries.count(params);
-
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: JSON.stringify(count),
-        },
-      ],
-    };
-  } catch (error) {
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: `Error counting countries: ${(error as Error).message}`,
-        },
-      ],
-    };
-  }
-}

package/src/mcp/tools/country/countriesHandler.ts

@@ -1,84 +0,0 @@
-import { z } from 'zod';
-import { Context } from '../../../context.js';
-import { SortDirection } from '@unchainedshop/utils';
-import { log } from '@unchainedshop/logger';
-
-const sortDirectionKeys = Object.keys(SortDirection) as [
-  keyof typeof SortDirection,
-  ...(keyof typeof SortDirection)[],
-];
-
-export const ListCountriesSchema = {
-  limit: z
-    .number()
-    .int()
-    .min(1)
-    .max(100)
-    .default(50)
-    .describe('Maximum number of countries to return (pagination limit)'),
-  offset: z
-    .number()
-    .int()
-    .min(0)
-    .default(0)
-    .describe('Number of countries to skip before starting to collect the result set'),
-  includeInactive: z
-    .boolean()
-    .default(false)
-    .describe('Whether to include inactive (disabled) countries in the results'),
-  queryString: z
-    .string()
-    .min(1)
-    .optional()
-    .describe('Optional case-insensitive text filter to search country name or code'),
-  sort: z
-    .array(
-      z.object({
-        key: z.string().min(1).describe('Field name to sort by (e.g., "name", "isoCode")'),
-        value: z.enum(sortDirectionKeys).describe('Sorting direction, either "ASC" or "DESC"'),
-      }),
-    )
-    .optional()
-    .describe('List of fields and their corresponding sort directions'),
-};
-
-export const ListCountriesZodSchema = z.object(ListCountriesSchema);
-
-export type ListCountriesParams = z.infer<typeof ListCountriesZodSchema>;
-
-export async function countriesHandler(context: Context, params: ListCountriesParams) {
-  const { limit, offset, includeInactive, queryString, sort } = params;
-  const { modules, userId } = context;
-
-  try {
-    log(`handler countriesHandler`, {
-      userId,
-      params,
-    });
-    const countries = await modules.countries.findCountries({
-      limit,
-      offset,
-      includeInactive,
-      queryString,
-      sort: sort as any[],
-    });
-
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: JSON.stringify({ countries }),
-        },
-      ],
-    };
-  } catch (error) {
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: `Error retrieving countries: ${(error as Error).message}`,
-        },
-      ],
-    };
-  }
-}

package/src/mcp/tools/country/countryHandler.ts

@@ -1,45 +0,0 @@
-import { z } from 'zod';
-import { Context } from '../../../context.js';
-import { CountryNotFoundError } from '../../../errors.js';
-import { log } from '@unchainedshop/logger';
-
-export const CountrySchema = {
-  countryId: z.string().min(1).describe('ID of the country to retrieve'),
-};
-
-export const CountryZodSchema = z.object(CountrySchema);
-
-export type CountryParams = z.infer<typeof CountryZodSchema>;
-
-export async function countryHandler(context: Context, params: CountryParams) {
-  const { countryId } = params;
-  const { modules, userId } = context;
-
-  try {
-    log(`handler countryHandler`, {
-      userId,
-      params,
-    });
-    const country = await modules.countries.findCountry({ countryId });
-
-    if (!country) throw new CountryNotFoundError({ countryId });
-
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: JSON.stringify({ country }),
-        },
-      ],
-    };
-  } catch (error) {
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: `Error retrieving country: ${(error as Error).message}`,
-        },
-      ],
-    };
-  }
-}