@unchainedshop/api 4.3.6 → 4.4.0

package/src/fastify/index.ts

@@ -1,329 +0,0 @@
-import { getCurrentContextResolver, LoginFn, LogoutFn } from '../context.js';
-import bulkImportHandler from './bulkImportHandler.js';
-import ercMetadataHandler from './ercMetadataHandler.js';
-import MongoStore from '../mongo-store.js';
-import { YogaServerInstance } from 'graphql-yoga';
-import { mongodb } from '@unchainedshop/mongodb';
-import { UnchainedCore } from '@unchainedshop/core';
-import { emit } from '@unchainedshop/events';
-import { API_EVENTS } from '../events.js';
-import { User } from '@unchainedshop/core-users';
-import fastifySession from '@fastify/session';
-import fastifyCookie from '@fastify/cookie';
-import fastifyMultipart from '@fastify/multipart';
-import { FastifyBaseLogger, FastifyInstance, FastifyPluginAsync, FastifyRequest } from 'fastify';
-import { createLogger } from '@unchainedshop/logger';
-import mcpHandler from './mcpHandler.js';
-import tempUploadHandler from './tempUploadHandler.js';
-import { connectChat } from './chatHandler.js';
-import { ChatConfiguration } from '../chat/utils.js';
-import { readFileSync } from 'node:fs';
-export interface AdminUIRouterOptions {
-  prefix: string;
-  enabled?: boolean;
-}
-
-const resolveUserRemoteAddress = (req: FastifyRequest) => {
-  const remoteAddress =
-    (req.headers['x-real-ip'] as string) ||
-    (req.headers['x-forwarded-for'] as string) ||
-    req.socket?.remoteAddress;
-
-  const remotePort = req.socket?.remotePort;
-
-  return { remoteAddress, remotePort };
-};
-
-const {
-  MCP_API_PATH = '/mcp',
-  GRAPHQL_API_PATH = '/graphql',
-  BULK_IMPORT_API_PATH = '/bulk-import',
-  TEMP_UPLOAD_API_PATH = '/temp-upload',
-  ERC_METADATA_API_PATH = '/erc-metadata/:productId/:localeOrTokenFilename/:tokenFileName?',
-  UNCHAINED_COOKIE_NAME = 'unchained_token',
-  UNCHAINED_COOKIE_PATH = '/',
-  UNCHAINED_COOKIE_DOMAIN,
-  UNCHAINED_COOKIE_SAMESITE = 'none',
-  UNCHAINED_COOKIE_INSECURE,
-} = process.env;
-
-const middlewareHook = async function middlewareHook(req: any, reply: any) {
-  const setHeader = (key, value) => reply.header(key, value);
-  const getHeader = (key) => req.headers[key];
-  const { remoteAddress, remotePort } = resolveUserRemoteAddress(req);
-
-  const context = getCurrentContextResolver();
-
-  const login: LoginFn = async function (user: User, options = {}) {
-    const { impersonator } = options;
-
-    req.session.userId = user._id;
-    req.session.impersonatorId = impersonator?._id;
-
-    const tokenObject = {
-      _id: req.session.sessionId,
-      userId: user._id,
-
-      tokenExpires: new Date((req as any).session.cookie._expires),
-    };
-    await emit(API_EVENTS.API_LOGIN_TOKEN_CREATED, tokenObject);
-
-    (user as any)._inLoginMethodResponse = true;
-    return { user, ...tokenObject };
-  };
-
-  const logout: LogoutFn = async function logout() {
-    const tokenObject = {
-      _id: (req as any).session.sessionId,
-      userId: req.session?.userId,
-    };
-    req.session.userId = null;
-    req.session.impersonatorId = null;
-    await emit(API_EVENTS.API_LOGOUT, tokenObject);
-    return true;
-  };
-
-  const [, accessToken] = req.headers.authorization?.split(' ') || [];
-
-  (req as any).unchainedContext = await context(
-    {
-      setHeader,
-      getHeader,
-      remoteAddress,
-      remotePort,
-      login,
-      logout,
-      accessToken,
-      userId: req.session.userId,
-      impersonatorId: req.session.impersonatorId,
-    },
-    req,
-    reply,
-  );
-};
-
-export const unchainedLogger = (prefix: string): FastifyBaseLogger => {
-  const logger = createLogger(prefix);
-  function Logger(...args) {
-    this.args = args;
-  }
-  Logger.prototype.info = logger.info;
-  Logger.prototype.error = logger.error;
-  Logger.prototype.debug = logger.debug;
-  Logger.prototype.fatal = logger.error;
-  Logger.prototype.warn = logger.warn;
-  Logger.prototype.trace = logger.trace;
-  Logger.prototype.child = function () {
-    return new Logger();
-  };
-  return new Logger();
-};
-
-export const connect = (
-  fastify: FastifyInstance,
-  {
-    graphqlHandler,
-    db,
-    unchainedAPI,
-  }: {
-    graphqlHandler: YogaServerInstance<any, any>;
-    db: mongodb.Db;
-    unchainedAPI: UnchainedCore;
-  },
-  {
-    allowRemoteToLocalhostSecureCookies = false,
-    adminUI = false,
-    chat,
-    initPluginMiddlewares,
-  }: {
-    allowRemoteToLocalhostSecureCookies?: boolean;
-    adminUI?: boolean | Omit<AdminUIRouterOptions, 'enabled'>;
-    chat?: ChatConfiguration;
-    initPluginMiddlewares?: (
-      app: FastifyInstance,
-      { unchainedAPI }: { unchainedAPI: UnchainedCore },
-    ) => void;
-  } = {},
-) => {
-  if (allowRemoteToLocalhostSecureCookies) {
-    // Workaround: Allow to use sandbox with localhost
-    // https://github.com/fastify/fastify-cookie/issues/308
-    fastify.addHook('preHandler', async function (request) {
-      request.headers['x-forwarded-proto'] = 'https';
-    });
-    fastify.addHook('onSend', async function (req, reply) {
-      reply.headers({
-        'Access-Control-Allow-Private-Network': 'true',
-        'Access-Control-Allow-Origin': req.headers.origin || '*',
-        'Access-Control-Allow-Credentials': 'true',
-        'Access-Control-Allow-Methods': ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'].join(', '),
-        'Access-Control-Allow-Headers': req.headers['access-control-request-headers'] || '*',
-      });
-    });
-  }
-
-  const cookieName = UNCHAINED_COOKIE_NAME;
-  const domain = UNCHAINED_COOKIE_DOMAIN;
-  const path = UNCHAINED_COOKIE_PATH;
-  const secure = UNCHAINED_COOKIE_INSECURE ? false : true;
-  const sameSite = ({
-    none: 'none',
-    lax: 'lax',
-    strict: 'strict',
-    '1': true,
-    '0': false,
-  }[UNCHAINED_COOKIE_SAMESITE?.trim()?.toLowerCase()] || false) as boolean | 'none' | 'lax' | 'strict';
-
-  if (!fastify.hasPlugin('@fastify/cookie')) {
-    fastify.register(fastifyCookie);
-  }
-  fastify.register(fastifySession as any, {
-    secret: process.env.UNCHAINED_TOKEN_SECRET,
-    cookieName,
-    store: MongoStore.create({
-      client: (db as any).client,
-      dbName: db.databaseName,
-      collectionName: 'sessions',
-    }),
-    cookie: {
-      domain,
-      httpOnly: true,
-      path,
-      secure,
-      sameSite,
-      maxAge: 1000 * 60 * 60 * 24 * 7,
-    },
-  });
-
-  fastify.decorateRequest('unchainedContext');
-  fastify.addHook('onRequest', middlewareHook);
-
-  fastify.route({
-    url: GRAPHQL_API_PATH,
-    method: ['GET', 'POST', 'OPTIONS'],
-    handler: async (req, reply) => {
-      // Second parameter adds Fastify's `req` and `reply` to the GraphQL Context
-      const response = await graphqlHandler.handleNodeRequestAndResponse(req, reply, {
-        req,
-        reply,
-      });
-      response.headers.forEach((value, key) => {
-        reply.header(key, value);
-      });
-      reply.status(response.status);
-      reply.send(response.body);
-      return reply;
-    },
-  });
-
-  fastify.route({
-    url: ERC_METADATA_API_PATH,
-    method: ['GET'],
-    handler: ercMetadataHandler,
-  });
-
-  fastify.route({
-    url: MCP_API_PATH,
-    method: ['GET', 'POST', 'DELETE'],
-    handler: mcpHandler,
-  });
-
-  fastify.register((s, opts, registered) => {
-    s.register(fastifyMultipart, { throwFileSizeLimit: true, limits: { fileSize: 1024 * 1024 * 35 } }); // 35MB
-    s.route({
-      url: TEMP_UPLOAD_API_PATH,
-      method: ['POST'],
-      bodyLimit: 1024 * 1024 * 35, // 35MB
-      handler: tempUploadHandler,
-    });
-    registered();
-  });
-
-  fastify.register((s, opts, registered) => {
-    s.removeAllContentTypeParsers();
-    s.addContentTypeParser('*', function (req, payload, done) {
-      done(null);
-    });
-    s.route({
-      url: BULK_IMPORT_API_PATH,
-      method: ['POST'],
-      bodyLimit: 1024 * 1024 * 1024 * 5, // 5GB
-      handler: bulkImportHandler,
-    });
-    registered();
-  });
-
-  if (chat) {
-    connectChat(fastify, chat);
-  }
-
-  if (initPluginMiddlewares) {
-    initPluginMiddlewares(fastify, { unchainedAPI });
-  }
-
-  if (adminUI) {
-    fastify.register(adminUIRouter, {
-      enabled: true,
-      prefix: typeof adminUI === 'object' ? adminUI.prefix : '/',
-    });
-  }
-};
-
-const fallbackLandingPageHandler = (request, reply) => {
-  if (request.raw.method === 'GET') {
-    const staticURL = import.meta.resolve('@unchainedshop/api/index.html');
-    const staticPath = new URL(staticURL).pathname.split('/').slice(0, -1).join('/');
-    return reply.type('text/html').send(readFileSync(staticPath + '/index.html'));
-  } else {
-    return reply.status(404).send();
-  }
-};
-
-const resolveAdminUIPath = () => {
-  try {
-    const staticURL = import.meta.resolve('@unchainedshop/admin-ui');
-    return new URL(staticURL).pathname.split('/').slice(0, -1).join('/');
-  } catch {
-    return null;
-  }
-};
-
-export const adminUIRouter: FastifyPluginAsync<AdminUIRouterOptions> = async (
-  fastify: FastifyInstance,
-  opts,
-) => {
-  try {
-    let fastifyStatic;
-    try {
-      const fastifyStaticModule = await import('@fastify/static');
-      fastifyStatic = fastifyStaticModule.default;
-    } catch {
-      fastify.log.warn("npm dependency @fastify/static is not installed, can't serve admin-ui");
-    }
-
-    if (fastifyStatic) {
-      const adminUIPath = resolveAdminUIPath();
-      if (adminUIPath) {
-        await fastify.register(fastifyStatic, {
-          root: adminUIPath,
-          prefix: opts.prefix || '/',
-        });
-        return;
-      }
-    }
-    await fastify.get(opts.prefix || '/', fallbackLandingPageHandler);
-  } catch (e) {
-    fastify.log.error(e);
-    if (process.env.NODE_ENV !== 'production') {
-      // Trying the default admin ui dev port
-      fastify.get('/', async (request, reply) => {
-        return reply.redirect('http://localhost:3000');
-      });
-    }
-  }
-};
-
-// @deprecated use adminUIRouter instead
-export const fastifyRouter = adminUIRouter;
-
-export { connectChat };

package/src/fastify/mcpHandler.ts

@@ -1,117 +0,0 @@
-import type * as mcpSDKServerLibraryTypes from '@modelcontextprotocol/sdk/server/streamableHttp.js';
-import type * as mcpSDKClientTypes from '@modelcontextprotocol/sdk/types.js';
-import type * as mcpSDKServerTypes from '@modelcontextprotocol/sdk/server/mcp.js';
-import type { Context } from '../context.js';
-import type { FastifyRequest, RouteHandlerMethod } from 'fastify';
-import initMCPServer from '../mcp/index.js';
-import { createLogger } from '@unchainedshop/logger';
-
-const logger = createLogger('unchained:api:mcp');
-
-let StreamableHTTPServerTransport: typeof mcpSDKServerLibraryTypes.StreamableHTTPServerTransport;
-let isInitializeRequest: typeof mcpSDKClientTypes.isInitializeRequest;
-let McpServer: typeof mcpSDKServerTypes.McpServer;
-
-try {
-  const mcpSDKServerLibrary = await import('@modelcontextprotocol/sdk/server/streamableHttp.js');
-  const mcpSDKClient = await import('@modelcontextprotocol/sdk/types.js');
-  const mcpSDKServer = await import('@modelcontextprotocol/sdk/server/mcp.js');
-
-  StreamableHTTPServerTransport = mcpSDKServerLibrary.StreamableHTTPServerTransport;
-  isInitializeRequest = mcpSDKClient.isInitializeRequest;
-  McpServer = mcpSDKServer.McpServer;
-} catch {
-  logger.warn(`optional peer npm package '@modelcontextprotocol/sdk' not installed, mcp will not work`);
-}
-
-const transports: Record<string, mcpSDKServerLibraryTypes.StreamableHTTPServerTransport> = {};
-
-const mcpHandler: RouteHandlerMethod = async (
-  req: FastifyRequest & { unchainedContext: Context },
-  res,
-) => {
-  if (!req.unchainedContext.user) {
-    res.status(401);
-    res.header(
-      'WWW-Authenticate',
-      `Bearer realm="Unchained MCP", error="invalid_token", resource="${process.env.ROOT_URL || 'http://localhost:4010'}",`,
-    );
-    return res.send(
-      JSON.stringify({
-        error: 'invalid_token',
-        resource_metadata: `${process.env.ROOT_URL || 'http://localhost:4010'}/.well-known/oauth-protected-resource`,
-      }),
-    );
-  }
-
-  try {
-    if (req.method === 'POST') {
-      const sessionId = req.headers['mcp-session-id'] as string | undefined;
-
-      let transport: mcpSDKServerLibraryTypes.StreamableHTTPServerTransport;
-
-      if (sessionId && transports[sessionId]) {
-        // Reuse existing transport
-        transport = transports[sessionId];
-      } else if (!sessionId && isInitializeRequest(req.body)) {
-        // New initialization request
-        transport = new StreamableHTTPServerTransport({
-          sessionIdGenerator: () => crypto.randomUUID(),
-          onsessioninitialized: (sessionId) => {
-            // Store the transport by session ID
-            transports[sessionId] = transport;
-          },
-        });
-
-        // Clean up transport when closed
-        transport.onclose = () => {
-          if (transport.sessionId) {
-            delete transports[transport.sessionId];
-          }
-        };
-
-        const roles = req.unchainedContext.user.roles || [];
-        const server = initMCPServer(
-          new McpServer({
-            name: 'Unchained MCP Server',
-            version: '1.0.0',
-          }),
-          req.unchainedContext,
-          roles,
-        );
-        await server.connect(transport);
-      } else {
-        // Invalid request
-        return res.status(400).send(
-          JSON.stringify({
-            jsonrpc: '2.0',
-            error: {
-              code: -32000,
-              message: 'Bad Request: No valid session ID provided',
-            },
-            id: null,
-          }),
-        );
-      }
-
-      await transport.handleRequest(req.raw, res.raw, req.body);
-      return res;
-    } else if (req.method === 'GET' || req.method === 'DELETE') {
-      const sessionId = req.headers['mcp-session-id'] as string | undefined;
-      if (!sessionId || !transports[sessionId]) {
-        return res.status(400).send('Invalid or missing session ID');
-      }
-
-      const transport = transports[sessionId];
-      await transport.handleRequest(req.raw, res.raw);
-      return res;
-    }
-
-    return res.status(405).send('Method Not Allowed');
-  } catch (e) {
-    logger.error(e);
-    return res.status(503).send({ name: e.name, code: e.code, message: e.message });
-  }
-};
-
-export default mcpHandler;

package/src/fastify/tempUploadHandler.ts

@@ -1,50 +0,0 @@
-import { createLogger } from '@unchainedshop/logger';
-import { getFileAdapter } from '@unchainedshop/core-files';
-import { checkAction } from '../acl.js';
-import { actions } from '../roles/index.js';
-import { Context } from '../context.js';
-import { FastifyRequest, RouteHandlerMethod } from 'fastify';
-
-const logger = createLogger('unchained:temp-upload');
-
-const tempUploadHandler: RouteHandlerMethod = async (
-  req: FastifyRequest & { file: any; unchainedContext: Context },
-  res,
-) => {
-  try {
-    const context = req.unchainedContext;
-
-    await checkAction(context, (actions as any).uploadTempFile);
-
-    const data = await req.file();
-
-    const file = await context.services.files.uploadFileFromStream({
-      directoryName: 'temp-uploads',
-      rawFile: Promise.resolve({
-        filename: data.filename,
-        createReadStream: () => data.file,
-        mimetype: data.mimetype,
-      }),
-      meta: { fieldname: data.fieldname, encoding: data.encoding },
-    });
-
-    // Add an expiration date to this file manually!
-    const expires = new Date(Date.now() + 24 * 60 * 60 * 1000);
-    await context.modules.files.update(file._id, {
-      expires, // Default to 1 hour
-    });
-
-    const fileUploadAdapter = getFileAdapter();
-    const rawUrl = await fileUploadAdapter.createDownloadURL(file);
-    if (!rawUrl) throw new Error('Could not create download URL for file');
-    const url = context.modules.files.normalizeUrl(rawUrl, {});
-    res.status(200);
-    return res.send({ fileId: file._id, url, expires: expires.toISOString() });
-  } catch (e) {
-    logger.error(e);
-    res.status(503);
-    return res.send({ name: e.name, code: e.code, message: e.message });
-  }
-};
-
-export default tempUploadHandler;

package/src/loaders/assortmentLinkLoader.ts

@@ -1,32 +0,0 @@
-import { UnchainedCore } from '@unchainedshop/core';
-import { AssortmentLink } from '@unchainedshop/core-assortments';
-import DataLoader from 'dataloader';
-
-export default (unchainedAPI: UnchainedCore) =>
-  new DataLoader<{ parentAssortmentId: string; childAssortmentId: string }, AssortmentLink>(
-    async (queries) => {
-      const parentAssortmentIds = [...new Set(queries.map((q) => q.parentAssortmentId).filter(Boolean))];
-
-      const links = await unchainedAPI.modules.assortments.links.findLinks({
-        parentAssortmentIds,
-      });
-
-      const assortmentLinkMap = {};
-      for (const link of links) {
-        if (!assortmentLinkMap[link.parentAssortmentId]) {
-          assortmentLinkMap[link.parentAssortmentId] = [link];
-        } else {
-          assortmentLinkMap[link.parentAssortmentId].push(link);
-        }
-      }
-
-      return queries.map((q) => {
-        if (q.childAssortmentId) {
-          return assortmentLinkMap[q.parentAssortmentId].find(
-            (link) => link.childAssortmentId === q.childAssortmentId,
-          );
-        }
-        return assortmentLinkMap[q.parentAssortmentId][0];
-      });
-    },
-  );

package/src/loaders/assortmentLinksLoader.ts

@@ -1,49 +0,0 @@
-import { UnchainedCore } from '@unchainedshop/core';
-import { AssortmentLink } from '@unchainedshop/core-assortments';
-import DataLoader from 'dataloader';
-
-export default (unchainedAPI: UnchainedCore) =>
-  new DataLoader<
-    { parentAssortmentId?: string; childAssortmentId?: string; assortmentId?: string },
-    AssortmentLink[]
-  >(async (queries) => {
-    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])],
-    });
-
-    const parentAssortmentLinkMap = {};
-    const childAssortmentLinkMap = {};
-
-    for (const link of allLinks) {
-      if (!parentAssortmentLinkMap[link.parentAssortmentId]) {
-        parentAssortmentLinkMap[link.parentAssortmentId] = [link];
-      } else {
-        parentAssortmentLinkMap[link.parentAssortmentId].push(link);
-      }
-
-      if (!childAssortmentLinkMap[link.childAssortmentId]) {
-        childAssortmentLinkMap[link.childAssortmentId] = [link];
-      } else {
-        childAssortmentLinkMap[link.childAssortmentId].push(link);
-      }
-    }
-
-    return queries.map((q) => {
-      if (q.parentAssortmentId) {
-        return parentAssortmentLinkMap[q.parentAssortmentId] || [];
-      } else if (q.childAssortmentId) {
-        return childAssortmentLinkMap[q.childAssortmentId] || [];
-      }
-      if (q.assortmentId) {
-        return [
-          ...(parentAssortmentLinkMap[q.assortmentId] || []),
-          ...(childAssortmentLinkMap[q.assortmentId] || []),
-        ];
-      }
-      return [];
-    });
-  });

package/src/loaders/assortmentLoader.ts

@@ -1,20 +0,0 @@
-import { UnchainedCore } from '@unchainedshop/core';
-import { Assortment } from '@unchainedshop/core-assortments';
-import DataLoader from 'dataloader';
-
-export default (unchainedAPI: UnchainedCore) =>
-  new DataLoader<{ assortmentId: string }, Assortment>(async (queries) => {
-    const assortmentIds = [...new Set(queries.map((q) => q.assortmentId).filter(Boolean))];
-
-    const assortments = await unchainedAPI.modules.assortments.findAssortments({
-      assortmentIds,
-      includeInactive: true,
-      includeLeaves: true,
-    });
-
-    const assortmentMap = {};
-    for (const assortment of assortments) {
-      assortmentMap[assortment._id] = assortment;
-    }
-    return queries.map((q) => assortmentMap[q.assortmentId]);
-  });

package/src/loaders/assortmentMediaTextLoader.ts

@@ -1,26 +0,0 @@
-import { UnchainedCore } from '@unchainedshop/core';
-import { AssortmentMediaText } from '@unchainedshop/core-assortments';
-import DataLoader from 'dataloader';
-import buildTextMap from './buildTextMap.js';
-import buildLocaleMap from './buildLocaleMap.js';
-
-export default (unchainedAPI: UnchainedCore) =>
-  new DataLoader<{ assortmentMediaId: string; locale: Intl.Locale }, AssortmentMediaText>(
-    async (queries) => {
-      const assortmentMediaIds = [...new Set(queries.map((q) => q.assortmentMediaId).filter(Boolean))];
-
-      const texts = await unchainedAPI.modules.assortments.media.texts.findMediaTexts(
-        { assortmentMediaId: { $in: assortmentMediaIds } },
-        {
-          sort: {
-            assortmentMediaId: 1,
-          },
-        },
-      );
-
-      const localeMap = buildLocaleMap(queries, texts);
-      const textsMap = buildTextMap(localeMap, texts, (text) => text.assortmentMediaId);
-
-      return queries.map((q) => textsMap[q.locale + q.assortmentMediaId]);
-    },
-  );

package/src/loaders/assortmentMediasLoader.ts

@@ -1,21 +0,0 @@
-import { UnchainedCore } from '@unchainedshop/core';
-import { AssortmentMediaType } from '@unchainedshop/core-assortments';
-import DataLoader from 'dataloader';
-
-export default (unchainedAPI: UnchainedCore) =>
-  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 },
-    });
-
-    const assortmentMediaMap = {};
-    for (const assortmentMedia of assortmentMediaItems) {
-      if (!assortmentMediaMap[assortmentMedia.assortmentId]) {
-        assortmentMediaMap[assortmentMedia.assortmentId] = [assortmentMedia];
-      } else {
-        assortmentMediaMap[assortmentMedia.assortmentId].push(assortmentMedia);
-      }
-    }
-    return queries.map((q) => assortmentMediaMap[q.assortmentId] || []);
-  });

package/src/loaders/assortmentProductLoader.ts

@@ -1,19 +0,0 @@
-import { UnchainedCore } from '@unchainedshop/core';
-import { AssortmentProduct } from '@unchainedshop/core-assortments';
-import DataLoader from 'dataloader';
-
-export default (unchainedAPI: UnchainedCore) =>
-  new DataLoader<{ assortmentId: string; productId: string }, AssortmentProduct>(async (queries) => {
-    const assortmentIds = [...new Set(queries.map((q) => q.assortmentId).filter(Boolean))];
-
-    const assortmentProducts = await unchainedAPI.modules.assortments.products.findAssortmentProducts({
-      assortmentIds,
-    });
-
-    const assortmentProductMap = {};
-    for (const assortmentProduct of assortmentProducts) {
-      assortmentProductMap[assortmentProduct.assortmentId + assortmentProduct.productId] =
-        assortmentProduct;
-    }
-    return queries.map((q) => assortmentProductMap[q.assortmentId + q.productId]);
-  });

package/src/loaders/assortmentProductsLoader.ts

@@ -1,22 +0,0 @@
-import { UnchainedCore } from '@unchainedshop/core';
-import { AssortmentProduct } from '@unchainedshop/core-assortments';
-import DataLoader from 'dataloader';
-
-export default (unchainedAPI: UnchainedCore) =>
-  new DataLoader<{ productId: string }, AssortmentProduct[]>(async (queries) => {
-    const productIds = [...new Set(queries.map((q) => q.productId).filter(Boolean))];
-
-    const assortmentProducts = await unchainedAPI.modules.assortments.products.findAssortmentProducts({
-      productIds,
-    });
-
-    const assortmentProductsMap = {};
-    for (const assortmentProduct of assortmentProducts) {
-      if (!assortmentProductsMap[assortmentProduct.productId]) {
-        assortmentProductsMap[assortmentProduct.productId] = [assortmentProduct];
-      } else {
-        assortmentProductsMap[assortmentProduct.productId].push(assortmentProduct);
-      }
-    }
-    return queries.map((q) => assortmentProductsMap[q.productId] || []);
-  });