@unchainedshop/api 3.0.0-alpha7 → 3.0.0-rc1

package/src/loaders/index.ts

@@ -1,8 +1,58 @@
 import DataLoader from 'dataloader';
 import { systemLocale } from '@unchainedshop/utils';
 import { UnchainedCore } from '@unchainedshop/core';
-import { ProductStatus } from '@unchainedshop/core-products';
-import { UnchainedLoaders } from '../types.js';
+import { Product, ProductText, ProductMediaText, ProductMedia } from '@unchainedshop/core-products';
+import { Filter, FilterText } from '@unchainedshop/core-filters';
+import {
+  Assortment,
+  AssortmentLink,
+  AssortmentProduct,
+  AssortmentText,
+  AssortmentMediaType,
+  AssortmentMediaText,
+} from '@unchainedshop/core-assortments';
+import { File } from '@unchainedshop/core-files';
+export interface UnchainedLoaders {
+  loaders: {
+    productLoader: InstanceType<typeof DataLoader<{ productId: string }, Product>>;
+    productLoaderBySKU: InstanceType<typeof DataLoader<{ sku: string }, Product>>;
+    productTextLoader: InstanceType<
+      typeof DataLoader<{ productId: string; locale: string }, ProductText>
+    >;
+    productMediaTextLoader: InstanceType<
+      typeof DataLoader<{ productMediaId: string; locale: string }, ProductMediaText>
+    >;
+
+    fileLoader: InstanceType<typeof DataLoader<{ fileId: string }, File>>;
+
+    filterLoader: InstanceType<typeof DataLoader<{ filterId: string }, Filter>>;
+    filterTextLoader: InstanceType<
+      typeof DataLoader<{ filterId: string; filterOptionValue?: string; locale: string }, FilterText>
+    >;
+
+    assortmentLoader: InstanceType<typeof DataLoader<{ assortmentId: string }, Assortment>>;
+    assortmentTextLoader: InstanceType<
+      typeof DataLoader<{ assortmentId: string; locale: string }, AssortmentText>
+    >;
+    assortmentLinkLoader: InstanceType<
+      typeof DataLoader<{ parentAssortmentId: string; childAssortmentId: string }, AssortmentLink>
+    >;
+    assortmentLinksLoader: InstanceType<
+      typeof DataLoader<{ parentAssortmentId?: string; assortmentId?: string }, AssortmentLink[]>
+    >;
+    assortmentProductLoader: InstanceType<
+      typeof DataLoader<{ assortmentId: string; productId: string }, AssortmentProduct>
+    >;
+    assortmentMediaTextLoader: InstanceType<
+      typeof DataLoader<{ assortmentMediaId: string; locale: string }, AssortmentMediaText>
+    >;
+
+    productMediasLoader: InstanceType<typeof DataLoader<{ productId?: string }, ProductMedia[]>>;
+    assortmentMediasLoader: InstanceType<
+      typeof DataLoader<{ assortmentId?: string }, AssortmentMediaType[]>
+    >;
+  };
+}
 
 function getLocaleStrings(localeObj: Intl.Locale) {
   return [localeObj.baseName, localeObj.language, systemLocale.baseName, systemLocale.language];
@@ -30,273 +80,278 @@ function getFilteredQueries({ queries, texts, filterFn }) {
 
 const loaders = async (unchainedAPI: UnchainedCore): Promise<UnchainedLoaders['loaders']> => {
   return {
-    assortmentLoader: new DataLoader(
-      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,
+    assortmentLoader: new DataLoader(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,
+      });
+
+      return queries.map(({ assortmentId }) => {
+        return assortments.find((assortment) => {
+          if (assortment._id !== assortmentId) return false;
+          return true;
         });
+      });
+    }),
 
-        return queries.map(({ assortmentId }) => {
-          return assortments.find((assortment) => {
-            if (assortment._id !== assortmentId) return false;
-            return true;
-          });
-        });
-      },
-      { batchScheduleFn: (cb) => setImmediate(cb) },
-    ),
-
-    assortmentTextLoader: new DataLoader(
-      async (queries) => {
-        const assortmentIds = [...new Set(queries.map((q) => q.assortmentId).filter(Boolean))];
-
-        const texts = await unchainedAPI.modules.assortments.texts.findTexts(
-          { assortmentId: { $in: assortmentIds } },
-          {
-            sort: {
-              assortmentId: 1,
-            },
-          },
-        );
-
-        const filterFn =
-          ({ assortmentId }) =>
-          (text) =>
-            text.assortmentId === assortmentId;
-
-        return getFilteredQueries({ queries, texts, filterFn });
-      },
-      { batchScheduleFn: (cb) => setImmediate(cb) },
-    ),
-
-    assortmentMediaTextLoader: new DataLoader(
-      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,
-            },
+    assortmentTextLoader: new DataLoader(async (queries) => {
+      const assortmentIds = [...new Set(queries.map((q) => q.assortmentId).filter(Boolean))];
+
+      const texts = await unchainedAPI.modules.assortments.texts.findTexts(
+        { assortmentId: { $in: assortmentIds } },
+        {
+          sort: {
+            assortmentId: 1,
           },
-        );
+        },
+      );
 
-        const filterFn =
-          ({ assortmentMediaId }) =>
-          (text) =>
-            text.assortmentMediaId === assortmentMediaId;
+      const filterFn =
+        ({ assortmentId }) =>
+        (text) =>
+          text.assortmentId === assortmentId;
 
-        return getFilteredQueries({ queries, texts, filterFn });
-      },
-      { batchScheduleFn: (cb) => setImmediate(cb) },
-    ),
+      return getFilteredQueries({ queries, texts, filterFn });
+    }),
 
-    assortmentLinkLoader: new DataLoader(
-      async (queries) => {
-        const parentAssortmentIds = [
-          ...new Set(queries.map((q) => q.parentAssortmentId).filter(Boolean)),
-        ];
+    assortmentMediaTextLoader: new DataLoader(async (queries) => {
+      const assortmentMediaIds = [...new Set(queries.map((q) => q.assortmentMediaId).filter(Boolean))];
 
-        const links = await unchainedAPI.modules.assortments.links.findLinks({
-          parentAssortmentIds,
+      const texts = await unchainedAPI.modules.assortments.media.texts.findMediaTexts(
+        { assortmentMediaId: { $in: assortmentMediaIds } },
+        {
+          sort: {
+            assortmentMediaId: 1,
+          },
+        },
+      );
+
+      const filterFn =
+        ({ assortmentMediaId }) =>
+        (text) =>
+          text.assortmentMediaId === assortmentMediaId;
+
+      return getFilteredQueries({ queries, texts, filterFn });
+    }),
+
+    assortmentMediasLoader: new DataLoader(async (queries) => {
+      const assortmentIds = [...new Set(queries.map((q) => q.assortmentId).filter(Boolean))];
+      const assortmentMediaItems = await unchainedAPI.modules.assortments.media.findAssortmentMedias({
+        assortmentId: { $in: assortmentIds },
+      });
+
+      return queries.map((q) => {
+        return assortmentMediaItems.filter((i) => {
+          return i.assortmentId === q.assortmentId;
         });
+      });
+    }),
 
-        return queries.map(({ parentAssortmentId, childAssortmentId }) => {
-          return links.find((link) => {
-            if (link.parentAssortmentId !== parentAssortmentId) return false;
-            if (childAssortmentId && link.childAssortmentId !== childAssortmentId) return false;
-            return true;
-          });
-        });
-      },
-      { batchScheduleFn: (cb) => setImmediate(cb) },
-    ),
-
-    assortmentLinksLoader: new DataLoader(
-      async (queries) => {
-        const parentAssortmentIds = [
-          ...new Set(queries.flatMap((q) => q.parentAssortmentId).filter(Boolean)),
-        ];
-        const assortmentIds = [...new Set(queries.flatMap((q) => q.assortmentId).filter(Boolean))];
-
-        const linksByParentAssortmentId =
-          parentAssortmentIds?.length &&
-          (await unchainedAPI.modules.assortments.links.findLinks({
-            parentAssortmentIds,
-          }));
-        const linksByAssortmentId =
-          assortmentIds?.length &&
-          (await unchainedAPI.modules.assortments.links.findLinks({
-            assortmentIds,
-          }));
-
-        return queries.map(({ parentAssortmentId, assortmentId }) => {
-          if (parentAssortmentId) {
-            return linksByParentAssortmentId.filter(
-              (link) => link.parentAssortmentId === parentAssortmentId,
-            );
-          }
-          if (assortmentId) {
-            return linksByAssortmentId.filter(
-              (link) =>
-                link.parentAssortmentId === assortmentId || link.childAssortmentId === assortmentId,
-            );
-          }
-          return [];
-        });
-      },
-      { batchScheduleFn: (cb) => setImmediate(cb) },
-    ),
+    assortmentLinkLoader: new DataLoader(async (queries) => {
+      const parentAssortmentIds = [...new Set(queries.map((q) => q.parentAssortmentId).filter(Boolean))];
 
-    assortmentProductLoader: new DataLoader(
-      async (queries) => {
-        const assortmentIds = [...new Set(queries.map((q) => q.assortmentId).filter(Boolean))];
+      const links = await unchainedAPI.modules.assortments.links.findLinks({
+        parentAssortmentIds,
+      });
 
-        const assortmentProducts = await unchainedAPI.modules.assortments.products.findProducts({
+      return queries.map(({ parentAssortmentId, childAssortmentId }) => {
+        return links.find((link) => {
+          if (link.parentAssortmentId !== parentAssortmentId) return false;
+          if (childAssortmentId && link.childAssortmentId !== childAssortmentId) return false;
+          return true;
+        });
+      });
+    }),
+
+    assortmentLinksLoader: new DataLoader(async (queries) => {
+      const parentAssortmentIds = [
+        ...new Set(queries.flatMap((q) => q.parentAssortmentId).filter(Boolean)),
+      ];
+      const assortmentIds = [...new Set(queries.flatMap((q) => q.assortmentId).filter(Boolean))];
+
+      const linksByParentAssortmentId =
+        parentAssortmentIds?.length &&
+        (await unchainedAPI.modules.assortments.links.findLinks({
+          parentAssortmentIds,
+        }));
+      const linksByAssortmentId =
+        assortmentIds?.length &&
+        (await unchainedAPI.modules.assortments.links.findLinks({
           assortmentIds,
+        }));
+
+      return queries.map(({ parentAssortmentId, assortmentId }) => {
+        if (parentAssortmentId) {
+          return linksByParentAssortmentId.filter(
+            (link) => link.parentAssortmentId === parentAssortmentId,
+          );
+        }
+        if (assortmentId) {
+          return linksByAssortmentId.filter(
+            (link) =>
+              link.parentAssortmentId === assortmentId || link.childAssortmentId === assortmentId,
+          );
+        }
+        return [];
+      });
+    }),
+
+    assortmentProductLoader: new DataLoader(async (queries) => {
+      const assortmentIds = [...new Set(queries.map((q) => q.assortmentId).filter(Boolean))];
+
+      const assortmentProducts = await unchainedAPI.modules.assortments.products.findProducts({
+        assortmentIds,
+      });
+
+      return queries.map(({ assortmentId, productId }) => {
+        return assortmentProducts.find((assortmentProduct) => {
+          if (assortmentProduct.assortmentId !== assortmentId) return false;
+          if (assortmentProduct.productId !== productId) return false;
+          return true;
         });
+      });
+    }),
 
-        return queries.map(({ assortmentId, productId }) => {
-          return assortmentProducts.find((assortmentProduct) => {
-            if (assortmentProduct.assortmentId !== assortmentId) return false;
-            if (assortmentProduct.productId !== productId) return false;
-            return true;
-          });
-        });
-      },
-      { batchScheduleFn: (cb) => setImmediate(cb) },
-    ),
+    filterLoader: new DataLoader(async (queries) => {
+      const filterIds = [...new Set(queries.map((q) => q.filterId).filter(Boolean))];
 
-    filterLoader: new DataLoader(
-      async (queries) => {
-        const filterIds = [...new Set(queries.map((q) => q.filterId).filter(Boolean))];
+      const filters = await unchainedAPI.modules.filters.findFilters({
+        filterIds,
+        includeInactive: true,
+      });
 
-        const filters = await unchainedAPI.modules.filters.findFilters({
-          filterIds,
-          includeInactive: true,
+      return queries.map(({ filterId }) => {
+        return filters.find((product) => {
+          if (product._id !== filterId) return false;
+          return true;
         });
+      });
+    }),
 
-        return queries.map(({ filterId }) => {
-          return filters.find((product) => {
-            if (product._id !== filterId) return false;
-            return true;
-          });
-        });
-      },
-      { batchScheduleFn: (cb) => setImmediate(cb) },
-    ),
-
-    filterTextLoader: new DataLoader(
-      async (queries) => {
-        const filterIds = [...new Set(queries.map((q) => q.filterId).filter(Boolean))];
-
-        const texts = await unchainedAPI.modules.filters.texts.findTexts(
-          { filterId: { $in: filterIds } },
-          {
-            sort: {
-              filterId: 1,
-            },
-          },
-        );
-
-        const filterFn =
-          ({ filterId, filterOptionValue }) =>
-          (text) =>
-            text.filterId === filterId && text.filterOptionValue === filterOptionValue;
-        return getFilteredQueries({ queries, texts, filterFn });
-      },
-      { batchScheduleFn: (cb) => setImmediate(cb) },
-    ),
-
-    productLoader: new DataLoader(
-      async (queries) => {
-        const productIds = [...new Set(queries.map((q) => q.productId).filter(Boolean))]; // you don't need lodash, _.unique my ass
-
-        const products = await unchainedAPI.modules.products.findProducts({
-          productIds,
-          productSelector: {
-            status: { $in: [null, ProductStatus.ACTIVE, ProductStatus.DELETED] },
+    filterTextLoader: new DataLoader(async (queries) => {
+      const filterIds = [...new Set(queries.map((q) => q.filterId).filter(Boolean))];
+
+      const texts = await unchainedAPI.modules.filters.texts.findTexts(
+        { filterId: { $in: filterIds } },
+        {
+          sort: {
+            filterId: 1,
           },
+        },
+      );
+
+      const filterFn =
+        ({ filterId, filterOptionValue }) =>
+        (text) =>
+          text.filterId === filterId && text.filterOptionValue === filterOptionValue;
+      return getFilteredQueries({ queries, texts, filterFn });
+    }),
+
+    productLoader: new DataLoader(async (queries) => {
+      const productIds = [...new Set(queries.map((q) => q.productId).filter(Boolean))]; // you don't need lodash, _.unique my ass
+
+      const products = await unchainedAPI.modules.products.findProducts({
+        productIds,
+        productSelector: {
+          status: { $exists: true },
+        },
+      });
+
+      return queries.map(({ productId }) => {
+        return products.find((product) => {
+          if (product._id !== productId) return false;
+          return true;
         });
-
-        return queries.map(({ productId }) => {
-          return products.find((product) => {
-            if (product._id !== productId) return false;
-            return true;
-          });
+      });
+    }),
+
+    productLoaderBySKU: new DataLoader(async (queries) => {
+      const skus = [...new Set(queries.map((q) => q.sku).filter(Boolean))]; // you don't need lodash, _.unique my ass
+
+      const products = await unchainedAPI.modules.products.findProducts({
+        productSelector: {
+          'warehousing.sku': { $in: skus },
+          status: { $exists: true },
+        },
+      });
+
+      return queries.map(({ sku }) => {
+        return products.find((product) => {
+          if (product.warehousing?.sku !== sku) return false;
+          return true;
         });
-      },
-      { batchScheduleFn: (cb) => setImmediate(cb) },
-    ),
-
-    productTextLoader: new DataLoader(
-      async (queries) => {
-        const productIds = [...new Set(queries.map((q) => q.productId).filter(Boolean))];
-
-        const texts = await unchainedAPI.modules.products.texts.findTexts(
-          { productId: { $in: productIds } },
-          {
-            sort: {
-              productId: 1,
-            },
-          },
-        );
-
-        const filterFn =
-          ({ productId }) =>
-          (text) =>
-            text.productId === productId;
-
-        return getFilteredQueries({ queries, texts, filterFn });
-      },
-      { batchScheduleFn: (cb) => setImmediate(cb) },
-    ),
-
-    productMediaTextLoader: new DataLoader(
-      async (queries) => {
-        const productMediaIds = [...new Set(queries.map((q) => q.productMediaId).filter(Boolean))];
-
-        const texts = await unchainedAPI.modules.products.media.texts.findMediaTexts(
-          { productMediaId: { $in: productMediaIds } },
-          {
-            sort: {
-              productMediaId: 1,
-            },
+      });
+    }),
+
+    productTextLoader: new DataLoader(async (queries) => {
+      const productIds = [...new Set(queries.map((q) => q.productId).filter(Boolean))];
+
+      const texts = await unchainedAPI.modules.products.texts.findTexts(
+        { productId: { $in: productIds } },
+        {
+          sort: {
+            productId: 1,
           },
-        );
+        },
+      );
 
-        const filterFn =
-          ({ productMediaId }) =>
-          (text) =>
-            text.productMediaId === productMediaId;
+      const filterFn =
+        ({ productId }) =>
+        (text) =>
+          text.productId === productId;
 
-        return getFilteredQueries({ queries, texts, filterFn });
-      },
-      { batchScheduleFn: (cb) => setImmediate(cb) },
-    ),
+      return getFilteredQueries({ queries, texts, filterFn });
+    }),
 
-    fileLoader: new DataLoader(
-      async (queries) => {
-        const fileIds = [...new Set(queries.map((q) => q.fileId).filter(Boolean))]; // you don't need lodash, _.unique my ass
+    productMediaTextLoader: new DataLoader(async (queries) => {
+      const productMediaIds = [...new Set(queries.map((q) => q.productMediaId).filter(Boolean))];
 
-        const files = await unchainedAPI.modules.files.findFiles({
-          _id: { $in: fileIds },
+      const texts = await unchainedAPI.modules.products.media.texts.findMediaTexts(
+        { productMediaId: { $in: productMediaIds } },
+        {
+          sort: {
+            productMediaId: 1,
+          },
+        },
+      );
+
+      const filterFn =
+        ({ productMediaId }) =>
+        (text) =>
+          text.productMediaId === productMediaId;
+
+      return getFilteredQueries({ queries, texts, filterFn });
+    }),
+
+    productMediasLoader: new DataLoader(async (queries) => {
+      const productIds = [...new Set(queries.map((q) => q.productId).filter(Boolean))];
+      const productMediaItems = await unchainedAPI.modules.products.media.findProductMedias({
+        productId: { $in: productIds },
+      });
+      return queries.map((q) => {
+        return productMediaItems.filter((i) => {
+          return i.productId === q.productId;
         });
+      });
+    }),
+
+    fileLoader: new DataLoader(async (queries) => {
+      const fileIds = [...new Set(queries.map((q) => q.fileId).filter(Boolean))]; // you don't need lodash, _.unique my ass
+
+      const files = await unchainedAPI.modules.files.findFiles({
+        _id: { $in: fileIds },
+      });
 
-        return queries.map(({ fileId }) => {
-          return files.find((file) => {
-            if (file._id !== fileId) return false;
-            return true;
-          });
+      return queries.map(({ fileId }) => {
+        return files.find((file) => {
+          if (file._id !== fileId) return false;
+          return true;
         });
-      },
-      { batchScheduleFn: (cb) => setImmediate(cb) },
-    ),
+      });
+    }),
   };
 };
 

package/src/locale-context.ts

@@ -1,4 +1,3 @@
-import { log, LogLevel } from '@unchainedshop/logger';
 import {
   resolveBestCountry,
   resolveBestSupported,
@@ -6,14 +5,27 @@ import {
   systemLocale,
 } from '@unchainedshop/utils';
 import { UnchainedCore } from '@unchainedshop/core';
-import memoizee from 'memoizee';
-import { UnchainedHTTPServerContext, UnchainedLocaleContext } from './types.js';
+import pMemoize from 'p-memoize';
+import ExpiryMap from 'expiry-map';
+import { UnchainedHTTPServerContext } from './context.js';
+import { createLogger } from '@unchainedshop/logger';
+const logger = createLogger('unchained:api');
 
+export interface UnchainedLocaleContext {
+  countryContext: string;
+  localeContext: Intl.Locale;
+  currencyContext: string;
+  remoteAddress?: string;
+  remotePort?: string;
+  userAgent?: string;
+}
 const { NODE_ENV } = process.env;
 
 export type GetHeaderFn = (key: string) => string | string[];
 
-export const resolveDefaultContext = memoizee(
+const memoizeCache = new ExpiryMap(NODE_ENV === 'production' ? 1000 * 60 : 100); // Cached values expire after 10 seconds
+
+export const resolveDefaultContext = pMemoize(
   async ({ acceptLang, acceptCountry }, unchainedAPI) => {
     const languages = await unchainedAPI.modules.languages.findLanguages(
       { includeInactive: false },
@@ -44,9 +56,9 @@ export const resolveDefaultContext = memoizee(
     const countryObject = countries.find((country) => country.isoCode === countryContext);
     const currencyContext = resolveBestCurrency(countryObject.defaultCurrencyCode, currencies);
 
-    log(`Locale Context: Resolved ${localeContext.baseName} ${countryContext} ${currencyContext}`, {
-      level: LogLevel.Debug,
-    });
+    logger.debug(
+      `Locale Context: Resolved ${localeContext.baseName} ${countryContext} ${currencyContext}`,
+    );
 
     const newContext: UnchainedLocaleContext = {
       localeContext,
@@ -57,11 +69,8 @@ export const resolveDefaultContext = memoizee(
     return newContext;
   },
   {
-    maxAge: NODE_ENV === 'production' ? 1000 * 60 : 100, // minute or 100ms
-    promise: true,
-    normalizer(args) {
-      return `${args[0].acceptLang}-${args[0].acceptCountry}`;
-    },
+    cache: memoizeCache,
+    cacheKey: (p: any) => [p.acceptLang, p.acceptCountry].join('-'),
   },
 );
 
@@ -72,8 +81,9 @@ export const getLocaleContext = async (
     getHeader,
   }: {
     remoteAddress: string;
-    remotePort: number;
-  } & UnchainedHTTPServerContext,
+    remotePort: number | string;
+    getHeader: UnchainedHTTPServerContext['getHeader'];
+  },
   unchainedAPI: UnchainedCore,
 ): Promise<UnchainedLocaleContext> => {
   const userAgent = getHeader('user-agent');
@@ -81,5 +91,5 @@ export const getLocaleContext = async (
     { acceptLang: getHeader('accept-language'), acceptCountry: getHeader('x-shop-country') },
     unchainedAPI,
   );
-  return { remoteAddress, remotePort, userAgent, ...context };
+  return { remoteAddress, remotePort: String(remotePort), userAgent, ...context };
 };

package/src/resolvers/mutations/accounts/addEmail.ts

@@ -1,6 +1,6 @@
 import { log } from '@unchainedshop/logger';
 import { EmailAlreadyExistsError, UserNotFoundError } from '../../../errors.js';
-import { Context } from '../../../types.js';
+import { Context } from '../../../context.js';
 
 export default async function addEmail(
   root: never,

package/src/resolvers/mutations/accounts/addWeb3Address.ts

@@ -1,6 +1,6 @@
 import { log } from '@unchainedshop/logger';
 import { UserWeb3InvalidAddressError } from '../../../errors.js';
-import { Context } from '../../../types.js';
+import { Context } from '../../../context.js';
 
 export default async function addWeb3Address(
   root: never,

package/src/resolvers/mutations/accounts/addWebAuthnCredentials.ts

@@ -1,5 +1,5 @@
 import { log } from '@unchainedshop/logger';
-import { Context } from '../../../types.js';
+import { Context } from '../../../context.js';
 
 export default async function addWebAuthnCredentials(
   root: never,