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

package/src/mcp/tools/currency/currencyHandler.ts

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { CurrencyNotFoundError } from '../../../errors.js';
+
+export const CurrencySchema = {
+  currencyId: z.string().min(1).describe('The ID of the currency to fetch'),
+};
+
+export const CurrencyZodSchema = z.object(CurrencySchema);
+
+export type CurrencyParams = z.infer<typeof CurrencyZodSchema>;
+
+export async function currencyHandler(context: Context, params: CurrencyParams) {
+  const { currencyId } = params;
+  const { modules } = context;
+
+  try {
+    const currency = await modules.currencies.findCurrency({ currencyId });
+
+    if (!currency) throw new CurrencyNotFoundError({ currencyId });
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ currency }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error retrieving currency: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

package/src/mcp/tools/currency/removeCurrencyHandler.ts

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
+import { CurrencyNotFoundError } from '../../../errors.js';
+
+export const RemoveCurrencySchema = {
+  currencyId: z.string().min(1).describe('ID of the currency to remove'),
+};
+
+export const RemoveCurrencyZodSchema = z.object(RemoveCurrencySchema);
+
+export type RemoveCurrencyParams = z.infer<typeof RemoveCurrencyZodSchema>;
+
+export async function removeCurrencyHandler(context: Context, params: RemoveCurrencyParams) {
+  const { currencyId } = params;
+  const { modules, userId } = context;
+
+  try {
+    log(`mutation removeCurrency: ${currencyId}`, { userId });
+
+    if (!(await modules.currencies.currencyExists({ currencyId })))
+      throw new CurrencyNotFoundError({ currencyId });
+
+    await modules.currencies.delete(currencyId);
+
+    const removedCurrency = await modules.currencies.findCurrency({ currencyId });
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ currency: removedCurrency }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error removing currency: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

package/src/mcp/tools/currency/updateCurrencyHandler.ts

@@ -0,0 +1,56 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
+import { CurrencyNotFoundError } from '../../../errors.js';
+
+export const UpdateCurrencySchema = {
+  currencyId: z.string().min(1).describe('ID of the currency to update'),
+  currency: z.object({
+    isoCode: z
+      .string()
+      .min(3)
+      .max(3)
+      .toUpperCase()
+      .optional()
+      .describe('3-letter ISO currency code, e.g., "USD" if not valid throw error'),
+    contractAddress: z.string().optional().describe('Blockchain contract address'),
+    decimals: z.number().int().nonnegative().optional().describe('Decimal precision'),
+  }),
+};
+
+export const UpdateCurrencyZodSchema = z.object(UpdateCurrencySchema);
+export type UpdateCurrencyParams = z.infer<typeof UpdateCurrencyZodSchema>;
+
+export async function updateCurrencyHandler(context: Context, params: UpdateCurrencyParams) {
+  const { currencyId, currency } = params;
+  const { modules, userId } = context;
+
+  try {
+    log(`handler updateCurrency: ${currencyId}`, { userId });
+
+    if (!(await modules.currencies.currencyExists({ currencyId })))
+      throw new CurrencyNotFoundError({ currencyId });
+
+    await modules.currencies.update(currencyId, currency);
+
+    const updatedCurrency = await modules.currencies.findCurrency({ currencyId });
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ currency: updatedCurrency }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error updating currency: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

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

@@ -0,0 +1,65 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
+import { FilterDirector } from '@unchainedshop/core';
+import { getNormalizedFilterDetails } from '../../utils/getNormalizedFilterDetails.js';
+
+export const CreateFilterInputSchema = z.object({
+  key: z.string().min(1).describe('Unique key for the filter'),
+  type: z.enum(['SWITCH', 'SINGLE_CHOICE', 'MULTI_CHOICE', 'RANGE']).describe('Type of the filter'),
+  options: z.array(z.string().min(1)).optional().describe('Selectable options (if applicable)'),
+});
+
+export const FilterTextInputSchema = z.object({
+  locale: z
+    .string()
+    .min(1)
+    .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().min(1),
+  subtitle: z.string().optional(),
+});
+
+export const CreateFilterSchema = {
+  filter: CreateFilterInputSchema,
+  texts: z.array(FilterTextInputSchema).optional(),
+};
+
+export const CreateFilterZodSchema = z.object(CreateFilterSchema);
+
+export type CreateFilterParams = z.infer<typeof CreateFilterZodSchema>;
+
+export async function createFilterHandler(context: Context, params: CreateFilterParams) {
+  const { filter, texts = [] } = params;
+  const { modules, userId } = context;
+
+  try {
+    log('handler createFilter', { userId, filter, texts });
+
+    const newFilter = await modules.filters.create(filter as any);
+
+    await FilterDirector.invalidateProductIdCache(newFilter, context);
+    if (texts) {
+      await modules.filters.texts.updateTexts({ filterId: newFilter._id }, texts);
+    }
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ filter: await getNormalizedFilterDetails(newFilter._id, context) }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error creating filter: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

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

@@ -0,0 +1,64 @@
+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 FilterOptionTextInputSchema = z.object({
+  locale: z
+    .string()
+    .min(1)
+    .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(),
+  subtitle: z.string().optional(),
+});
+
+export const CreateFilterOptionSchema = {
+  filterId: z.string().min(1).describe('ID of the filter to add the option to'),
+  option: z.string().min(1).describe('Value of the new filter option'),
+  texts: z.array(FilterOptionTextInputSchema).optional().describe('Localized titles and subtitles'),
+};
+
+export const CreateFilterOptionZodSchema = z.object(CreateFilterOptionSchema);
+
+export type CreateFilterOptionParams = z.infer<typeof CreateFilterOptionZodSchema>;
+
+export async function createFilterOptionHandler(context: Context, params: CreateFilterOptionParams) {
+  const { filterId, option, texts = [] } = params;
+  const { modules, userId } = context;
+
+  try {
+    log('handler createFilterOption', { userId, filterId, option, texts });
+
+    const filter = await getNormalizedFilterDetails(filterId, context);
+    if (!filter) throw new FilterNotFoundError({ filterId });
+
+    const newOptions = await modules.filters.createFilterOption(filterId, { value: option });
+    await FilterDirector.invalidateProductIdCache(newOptions, context);
+
+    if (texts) {
+      await modules.filters.texts.updateTexts({ filterId, filterOptionValue: option }, texts);
+    }
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ filter }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error creating filter option: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

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

@@ -0,0 +1,46 @@
+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 GetFilterSchema = {
+  filterId: z.string().min(1).describe('ID of the filter to retrieve'),
+};
+
+export const GetFilterZodSchema = z.object(GetFilterSchema);
+
+export type GetFilterParams = z.infer<typeof GetFilterZodSchema>;
+
+export async function getFilterHandler(context: Context, params: GetFilterParams) {
+  const { filterId } = params;
+  const { userId } = context;
+
+  try {
+    log('handler getFilter', { userId, filterId });
+
+    const filter = await getNormalizedFilterDetails(filterId, context);
+
+    if (!filter) {
+      throw new FilterNotFoundError({ filterId });
+    }
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ filter }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error retrieving filter: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

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

@@ -0,0 +1,59 @@
+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 to sort by'),
+  value: z.enum(['ASC', 'DESC']).describe('Sort direction'),
+});
+
+export const GetFiltersSchema = {
+  limit: z.number().min(1).max(100).default(20),
+  offset: z.number().min(0).default(0),
+  includeInactive: z.boolean().default(false),
+  queryString: z.string().optional(),
+  sort: z.array(SortOptionInputSchema).optional(),
+};
+
+export const GetFiltersZodSchema = z.object(GetFiltersSchema);
+
+export type GetFiltersParams = z.infer<typeof GetFiltersZodSchema>;
+
+export async function getFiltersHandler(context: Context, params: GetFiltersParams) {
+  const { limit, offset, includeInactive, queryString, sort } = params;
+  const { modules, userId } = context;
+
+  try {
+    log('handler getFilters', {
+      userId,
+      limit,
+      offset,
+      includeInactive,
+      queryString,
+      sort,
+    });
+
+    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/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('ID of the filter to remove'),
+};
+
+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 removeFilter: ${filterId}`, { userId });
+
+    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('ID of the filter to remove option from'),
+  filterOptionValue: z.string().min(1).describe('Value of the 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 removeFilterOption', { userId, filterId, filterOptionValue });
+    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,53 @@
+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('ID of the filter to fetch texts for'),
+  filterOptionValue: z.string().optional().describe('Optional option value to fetch 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 translatedFilterTexts', { userId, filterId, filterOptionValue });
+
+    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(),
+  key: z.string().min(1).optional(),
+});
+
+export const UpdateFilterSchema = {
+  filterId: z.string().min(1).describe('ID of the filter to update'),
+  filter: UpdateFilterInputSchema,
+};
+
+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 updateFilter', { userId, filterId, filter });
+    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,54 @@
+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),
+  title: z.string().optional(),
+  subtitle: z.string().optional(),
+});
+
+export const UpdateFilterTextsSchema = {
+  filterId: z.string().min(1).describe('ID of the filter to update texts for'),
+  filterOptionValue: z.string().optional().describe('Optional filter option to localize'),
+  texts: z.array(FilterUpdateTextInputSchema).min(1).describe('Localized texts to create 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}`,
+        },
+      ],
+    };
+  }
+}