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

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

@@ -0,0 +1,48 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
+
+export const CountriesCountSchema = {
+  includeInactive: z
+    .boolean()
+    .optional()
+    .default(false)
+    .describe('Whether to include inactive countries in the count'),
+  queryString: z.string().optional().describe('Optional text search filter'),
+};
+
+export const CountriesCountZodSchema = z.object(CountriesCountSchema);
+
+export type CountriesCountParams = z.infer<typeof CountriesCountZodSchema>;
+
+// Handler function
+export async function countriesCountHandler(context: Context, params: CountriesCountParams) {
+  const { includeInactive = false, queryString } = params;
+  const { modules, userId } = context;
+
+  try {
+    log(`query countriesCount (includeInactive: ${includeInactive}, query: ${queryString || ''})`, {
+      userId,
+    });
+
+    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/{countriesHandler.ts → country/countriesHandler.ts}

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { Context } from '../../context.js';
+import { Context } from '../../../context.js';
 import { SortDirection } from '@unchainedshop/utils';
 
 const sortDirectionKeys = Object.keys(SortDirection) as [

package/src/mcp/tools/{countryHandler.ts → country/countryHandler.ts}

@@ -1,6 +1,6 @@
 import { z } from 'zod';
-import { Context } from '../../context.js';
-import { CountryNotFoundError } from '../../errors.js';
+import { Context } from '../../../context.js';
+import { CountryNotFoundError } from '../../../errors.js';
 
 export const CountrySchema = {
   countryId: z.string().min(1).describe('The ID of the country to fetch'),

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

@@ -0,0 +1,47 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
+
+export const CreateCountrySchema = {
+  country: z.object({
+    isoCode: z
+      .string()
+      .min(2)
+      .max(2)
+      .toUpperCase()
+      .describe('2-letter ISO 3166-1 alpha-2 country code (e.g., "CH", "US")'),
+  }),
+};
+
+export const CreateCountryZodSchema = z.object(CreateCountrySchema);
+export type CreateCountryParams = z.infer<typeof CreateCountryZodSchema>;
+
+export async function createCountryHandler(context: Context, params: CreateCountryParams) {
+  const { country } = params;
+  const { modules, userId } = context;
+  try {
+    log(`handler createCountry: ${country.isoCode}`, { userId });
+
+    const countryId = await modules.countries.create(country as any);
+
+    const newCountry = await modules.countries.findCountry({ countryId });
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ country: newCountry }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error creating country: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

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

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

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

@@ -0,0 +1,60 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
+import { CountryNotFoundError } from '../../../errors.js';
+
+export const UpdateCountrySchema = {
+  countryId: z.string().min(1).describe('ID of the country to update'),
+  country: z.object({
+    isoCode: z
+      .string()
+      .min(2)
+      .max(2)
+      .toUpperCase()
+      .describe('2-letter ISO 3166-1 alpha-2 country code (e.g., "CH", "US")'),
+    isActive: z.boolean().optional().describe('Whether the country is active'),
+    defaultCurrencyCode: z
+      .string()
+      .min(3)
+      .max(3)
+      .toUpperCase()
+      .optional()
+      .describe('Default currency code (e.g., "USD", "CHF")'),
+  }),
+};
+
+export const UpdateCountryZodSchema = z.object(UpdateCountrySchema);
+export type UpdateCountryParams = z.infer<typeof UpdateCountryZodSchema>;
+
+export async function updateCountryHandler(context: Context, params: UpdateCountryParams) {
+  const { country, countryId } = params;
+  const { modules, userId } = context;
+  try {
+    log(`handler updateCountry: ${countryId}`, { userId });
+
+    if (!(await modules.countries.countryExists({ countryId })))
+      throw new CountryNotFoundError({ countryId });
+
+    await modules.countries.update(countryId, country as any);
+
+    const updatedCountry = await modules.countries.findCountry({ countryId });
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ country: updatedCountry }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error updating country: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

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

@@ -0,0 +1,55 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
+
+export const CreateCurrencySchema = {
+  currency: z.object({
+    isoCode: z
+      .string()
+      .min(3)
+      .max(3)
+      .toUpperCase()
+      .describe('3-letter ISO currency code (e.g., "USD", "EUR", "CHF")'),
+    contractAddress: z.string().optional().describe('Blockchain contract address (optional)'),
+    decimals: z
+      .number()
+      .int()
+      .nonnegative()
+      .optional()
+      .describe('Decimal precision for the currency (optional)'),
+  }),
+};
+
+export const CreateCurrencyZodSchema = z.object(CreateCurrencySchema);
+export type CreateCurrencyParams = z.infer<typeof CreateCurrencyZodSchema>;
+
+export async function createCurrencyHandler(context: Context, params: CreateCurrencyParams) {
+  const { currency } = params;
+  const { modules, userId } = context;
+
+  try {
+    log(`Handler createCurrency: ${currency.isoCode}`, { userId });
+
+    const currencyId = await modules.currencies.create(currency as any);
+
+    const newCurrency = await modules.currencies.findCurrency({ currencyId });
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ currency: newCurrency }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error creating currency: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

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

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

package/src/mcp/tools/{currenciesHandler.ts → currency/currenciesHandler.ts}

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { Context } from '../../context.js';
+import { Context } from '../../../context.js';
 import { SortDirection } from '@unchainedshop/utils';
 
 const sortDirectionKeys = Object.keys(SortDirection) as [

package/src/mcp/tools/{currencyHandler.ts → currency/currencyHandler.ts}

@@ -1,6 +1,6 @@
 import { z } from 'zod';
-import { Context } from '../../context.js';
-import { CurrencyNotFoundError } from '../../errors.js';
+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'),

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}`,
+        },
+      ],
+    };
+  }
+}