@unchainedshop/api 2.0.0-beta5 → 2.0.0-beta7

package/src/errors.ts

@@ -1,9 +1,14 @@
-import { ApolloError } from 'apollo-server-express';
+import { GraphQLError } from 'graphql';
 
 export const createError = (code: string, message: string): any =>
-  class extends ApolloError {
+  class extends GraphQLError {
     constructor({ message: explicitMessage, ...data }) {
-      super(explicitMessage || message, code, data);
+      super(explicitMessage || message, {
+        extensions: {
+          code,
+          ...data,
+        },
+      });
     }
   };
 

package/src/loaders/index.ts

@@ -3,10 +3,11 @@ import DataLoader from 'dataloader';
 import { IncomingMessage, OutgoingMessage } from 'http';
 import { systemLocale } from '@unchainedshop/utils';
 import localePkg from 'locale';
-import { AssortmentText } from '@unchainedshop/types/assortments';
-import { FilterText } from '@unchainedshop/types/filters';
-import { ProductText } from '@unchainedshop/types/products';
+import { Assortment, AssortmentText } from '@unchainedshop/types/assortments';
+import { Filter, FilterText } from '@unchainedshop/types/filters';
+import { Product, ProductText } from '@unchainedshop/types/products';
 import { UnchainedCore } from '@unchainedshop/types/core';
+import { ProductStatus } from '@unchainedshop/core-products';
 
 const { Locale } = localePkg;
 
@@ -16,6 +17,28 @@ export default async (
   unchainedAPI: UnchainedCore,
 ): Promise<UnchainedLoaders['loaders']> => {
   return {
+    assortmentLoader: new DataLoader<{ assortmentId: string; includeInactive: boolean }, 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,
+        });
+
+        return queries.map(({ assortmentId, includeInactive }) => {
+          return assortments.find((assortment) => {
+            if (assortment._id !== assortmentId) return false;
+            if (!includeInactive) {
+              return assortment.isActive === true;
+            }
+            return true;
+          });
+        });
+      },
+    ),
+
     assortmentTextLoader: new DataLoader<{ assortmentId: string; locale: string }, AssortmentText>(
       async (queries) => {
         const assortmentIds = [...new Set(queries.map((q) => q.assortmentId).filter(Boolean))];
@@ -46,6 +69,22 @@ export default async (
       },
     ),
 
+    filterLoader: new DataLoader<{ filterId: string }, Filter>(async (queries) => {
+      const filterIds = [...new Set(queries.map((q) => q.filterId).filter(Boolean))];
+
+      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;
+        });
+      });
+    }),
+
     filterTextLoader: new DataLoader<
       { filterId: string; filterOptionValue?: string; locale: string },
       FilterText
@@ -79,6 +118,27 @@ export default async (
       });
     }),
 
+    productLoader: new DataLoader<{ productId: string; includeDrafts: boolean }, Product>(
+      async (queries) => {
+        const productIds = [...new Set(queries.map((q) => q.productId).filter(Boolean))];
+
+        const products = await unchainedAPI.modules.products.findProducts({
+          productIds,
+          includeDrafts: true,
+        });
+
+        return queries.map(({ productId, includeDrafts }) => {
+          return products.find((product) => {
+            if (product._id !== productId) return false;
+            if (!includeDrafts) {
+              return product.status === ProductStatus.ACTIVE;
+            }
+            return true;
+          });
+        });
+      },
+    ),
+
     productTextLoader: new DataLoader<{ productId: string; locale: string }, ProductText>(
       async (queries) => {
         const productIds = [...new Set(queries.map((q) => q.productId).filter(Boolean))];

package/src/resolvers/index.ts

@@ -1,4 +1,4 @@
-import { GraphQLUpload } from 'graphql-upload';
+import GraphQLUpload from 'graphql-upload/GraphQLUpload.mjs';
 import { JSONResolver, TimestampResolver, DateTimeResolver, DateResolver } from 'graphql-scalars';
 import Query from './queries';
 import Mutation from './mutations';

package/src/resolvers/mutations/filters/updateFilter.ts

@@ -16,5 +16,7 @@ export default async function updateFilter(
 
   if (!(await modules.filters.filterExists({ filterId }))) throw new FilterNotFoundError({ filterId });
 
-  return modules.filters.update(filterId, filter, context, { skipInvalidation: false }, userId);
+  await modules.filters.update(filterId, filter, context, { skipInvalidation: false }, userId);
+
+  return modules.filters.findFilter({ filterId });
 }

package/src/resolvers/queries/products/product.ts

@@ -7,7 +7,7 @@ export default async function product(
   { productId, slug }: { productId?: string; slug?: string },
   { modules, userId }: Context,
 ) {
-  log(`query product ${productId} ${slug}`, { userId });
+  log(`query product ${productId || slug}`, { userId });
 
   if (!productId === !slug) throw new InvalidIdError({ productId, slug });
 

package/src/resolvers/queries/products/productCatalogPrices.ts

@@ -5,13 +5,16 @@ import { InvalidIdError } from '../../../errors';
 export default async function productCatalogPrices(
   root: Root,
   { productId }: { productId: string },
-  { modules, userId }: Context,
+  { modules, loaders, userId }: Context,
 ) {
   log(`query productCatalogPrices ${productId}`, { userId });
 
   if (!productId) throw new InvalidIdError({ productId });
 
-  const product = await modules.products.findProduct({ productId });
+  const product = await loaders.productLoader.load({
+    productId,
+    includeDrafts: true,
+  });
   if (!product) return null;
 
   return modules.products.prices.catalogPrices(product);

package/src/resolvers/queries/products/products.ts

@@ -12,7 +12,7 @@ export default async function products(
   { modules, userId }: Context,
 ) {
   log(
-    `query products: ${params.limit} ${params.offset} ${
+    `query products: ${params.limit || 0} ${params.offset || 0} ${
       params.includeDrafts ? 'includeDrafts' : ''
     } ${params.slugs?.join(',')}`,
     { userId },

package/src/resolvers/type/assortment/assortment-filter-types.ts

@@ -10,13 +10,18 @@ export type AssortmentFilterHelperTypes = {
 };
 
 export const AssortmentFilter: AssortmentFilterHelperTypes = {
-  assortment: (obj, _, { modules }) =>
-    modules.assortments.findAssortment({
+  assortment: async (obj, _, { loaders }) => {
+    const assortment = await loaders.assortmentLoader.load({
       assortmentId: obj.assortmentId,
-    }),
+      includeInactive: true,
+    });
+    return assortment;
+  },
 
-  filter: (obj, _, { modules }) =>
-    modules.filters.findFilter({
+  filter: async (obj, _, { loaders }) => {
+    const filter = await loaders.filterLoader.load({
       filterId: obj.filterId,
-    }),
+    });
+    return filter;
+  },
 };

package/src/resolvers/type/assortment/assortment-link-types.ts

@@ -9,13 +9,19 @@ export type AssortmentLinkHelperTypes = {
 };
 
 export const AssortmentLink: AssortmentLinkHelperTypes = {
-  child: (obj, _, { modules }) =>
-    modules.assortments.findAssortment({
+  child: async (obj, _, { loaders }) => {
+    const assortment = await loaders.assortmentLoader.load({
       assortmentId: obj.childAssortmentId,
-    }),
+      includeInactive: true,
+    });
+    return assortment;
+  },
 
-  parent: (obj, _, { modules }) =>
-    modules.assortments.findAssortment({
+  parent: async (obj, _, { loaders }) => {
+    const assortment = await loaders.assortmentLoader.load({
       assortmentId: obj.parentAssortmentId,
-    }),
+      includeInactive: true,
+    });
+    return assortment;
+  },
 };

package/src/resolvers/type/assortment/assortment-product-types.ts

@@ -13,13 +13,19 @@ export type AssortmentProductHelperTypes = {
 };
 
 export const AssortmentProduct: AssortmentProductHelperTypes = {
-  assortment: (obj, _, { modules }) =>
-    modules.assortments.findAssortment({
+  assortment: async (obj, _, { loaders }) => {
+    const assortment = await loaders.assortmentLoader.load({
       assortmentId: obj.assortmentId,
-    }),
+      includeInactive: true,
+    });
+    return assortment;
+  },
 
-  product: (obj, _, { modules }) =>
-    modules.products.findProduct({
+  product: async (obj, _, { loaders }) => {
+    const product = await loaders.productLoader.load({
       productId: obj.productId,
-    }),
+      includeDrafts: true,
+    });
+    return product;
+  },
 };

package/src/resolvers/type/bookmark-types.ts

@@ -11,9 +11,14 @@ export interface BookmarkHelperTypes {
 }
 
 export const Bookmark: BookmarkHelperTypes = {
-  product: async (obj, _, { modules }) => {
-    return modules.products.findProduct({ productId: obj.productId });
+  product: async (obj, _, { loaders }) => {
+    const product = await loaders.productLoader.load({
+      productId: obj.productId,
+      includeDrafts: true,
+    });
+    return product;
   },
+
   user: async (obj, _, { modules }) => {
     return modules.users.findUserById(obj.userId);
   },

package/src/resolvers/type/enrollment/enrollment-plan-tyes.ts

@@ -9,7 +9,11 @@ type EnrollmentPlanHelperTypes = {
 };
 
 export const EnrollmentPlan: EnrollmentPlanHelperTypes = {
-  product: async (plan, _, { modules }) => {
-    return modules.products.findProduct({ productId: plan.productId });
+  product: async (plan, _, { loaders }) => {
+    const product = await loaders.productLoader.load({
+      productId: plan.productId,
+      includeDrafts: true,
+    });
+    return product;
   },
 };

package/src/resolvers/type/order/order-item-types.ts

@@ -57,7 +57,7 @@ export const OrderItem: OrderItemHelperTypes = {
     return [];
   },
 
-  dispatches: async (obj, _, { modules }) => {
+  dispatches: async (obj, _, { modules, loaders }) => {
     const scheduling = obj.scheduling || [];
     const order = await modules.orders.findOrder({ orderId: obj.orderId });
     const { countryCode, userId } = order;
@@ -68,8 +68,9 @@ export const OrderItem: OrderItemHelperTypes = {
     const deliveryProvider = await modules.delivery.findProvider({
       deliveryProviderId: orderDelivery.deliveryProviderId,
     });
-    const product = await modules.products.findProduct({
+    const product = await loaders.productLoader.load({
       productId: obj.productId,
+      includeDrafts: true,
     });
 
     return Promise.all(
@@ -99,14 +100,20 @@ export const OrderItem: OrderItemHelperTypes = {
     return modules.orders.findOrder({ orderId: obj.orderId });
   },
 
-  originalProduct: async (obj, _, { modules }) => {
-    return modules.products.findProduct({
+  originalProduct: async (obj, _, { loaders }) => {
+    const product = await loaders.productLoader.load({
       productId: obj.originalProductId,
+      includeDrafts: true,
     });
+    return product;
   },
 
-  product: async (obj, _, { modules }) => {
-    return modules.products.findProduct({ productId: obj.productId });
+  product: async (obj, _, { loaders }) => {
+    const product = await loaders.productLoader.load({
+      productId: obj.productId,
+      includeDrafts: true,
+    });
+    return product;
   },
 
   quotation: async (obj, _, { modules }) => {

package/src/resolvers/type/product/product-bundle-item-types.ts

@@ -1,9 +1,11 @@
 import { ProductBundleItemHelperTypes } from '@unchainedshop/types/products';
 
 export const ProductBundleItem: ProductBundleItemHelperTypes = {
-  product: async (productItem, _, { modules }) => {
-    return modules.products.findProduct({
+  product: async (productItem, _, { loaders }) => {
+    const product = await loaders.productLoader.load({
       productId: productItem.productId,
+      includeDrafts: true,
     });
+    return product;
   },
 };

package/src/resolvers/type/product/product-review-types.ts

@@ -20,8 +20,12 @@ export const ProductReview: ProductReviewHelperTypes = {
     return modules.users.findUserById(obj.authorId);
   },
 
-  product: async (obj, _, { modules }) => {
-    return modules.products.findProduct({ productId: obj.productId });
+  product: async (review, _, { loaders }) => {
+    const product = await loaders.productLoader.load({
+      productId: review.productId,
+      includeDrafts: true,
+    });
+    return product;
   },
 
   ownVotes: async (obj, _, { modules, userId }) => {

package/src/resolvers/type/product/product-tokenized-types.ts

@@ -14,6 +14,7 @@ export const TokenizedProduct: TokenizedProductHelperTypes = {
     return {
       supply: product.tokenization.supply,
       tokenId: product.tokenization.tokenId,
+      ercMetadataProperties: product.tokenization.ercMetadataProperties,
     };
   },
 

package/src/resolvers/type/product/product-variation-assignment-types.ts

@@ -11,9 +11,11 @@ export const ProductVariationAssignment: ProductVariationAssignmentHelperTypes =
       product,
     }));
   },
-  product: async ({ assignment }, _, { modules }) => {
-    return modules.products.findProduct({
+  product: async ({ assignment }, _, { loaders }) => {
+    const product = await loaders.productLoader.load({
       productId: assignment.productId,
+      includeDrafts: true,
     });
+    return product;
   },
 };

package/src/resolvers/type/quotation-types.ts

@@ -24,10 +24,13 @@ export const Quotation: QuotationHelperTypes = {
   isExpired: (obj, { referenceDate }, { modules }) =>
     modules.quotations.isExpired(obj, { referenceDate }),
 
-  product: (obj, _, { modules }) =>
-    modules.products.findProduct({
+  product: async (obj, _, { loaders }) => {
+    const product = await loaders.productLoader.load({
       productId: obj.productId,
-    }),
+      includeDrafts: true,
+    });
+    return product;
+  },
 
   status: (obj, _, { modules }) => modules.quotations.normalizedStatus(obj),
 

package/src/resolvers/type/token-types.ts

@@ -46,8 +46,9 @@ export const Token: TokenHelperTypes = {
     const { modules } = context;
     const product = await modules.products.findProduct({ productId: token.productId });
     const ercMetadata = await modules.warehousing.tokenMetadata(
-      token,
+      token.chainTokenId,
       {
+        token,
         product,
         referenceDate: new Date(),
       },

package/src/schema/types/product/tokenized-product.js

@@ -5,6 +5,7 @@ export default [
       contractStandard: SmartContractStandard!
       tokenId: String
       supply: Int
+      ercMetadataProperties: JSON
     }
 
     enum SmartContractStandard {
@@ -15,6 +16,7 @@ export default [
     type ContractConfiguration {
       tokenId: String
       supply: Int
+      ercMetadataProperties: JSON
     }
 
     """

package/tsconfig.json

@@ -4,6 +4,7 @@
     "allowSyntheticDefaultImports": true,
     "declaration": true,
     "esModuleInterop": true,
+    "resolveJsonModule": true,
     "experimentalDecorators": true,
     "forceConsistentCasingInFileNames": true,
     "lib": [