@unchainedshop/api 2.0.0-beta6 → 2.0.0-beta8

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

@@ -4,19 +4,17 @@ import { Context, Root } from '@unchainedshop/types/api';
 export default async function changePassword(
   root: Root,
   params: {
-    oldPassword?: string;
     oldPlainPassword?: string;
-    newPassword?: string;
     newPlainPassword?: string;
   },
   { modules, userId }: Context,
 ) {
   log('mutation changePassword', { userId });
 
-  if (!params.newPassword && !params.newPlainPassword) {
+  if (!params.newPlainPassword) {
     throw new Error('New password is required');
   }
-  if (!params.oldPassword && !params.oldPlainPassword) {
+  if (!params.oldPlainPassword) {
     throw new Error('Old password is required');
   }
 

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

@@ -8,12 +8,12 @@ export default async function createUser(root: Root, params: UserData, context:
 
   log('mutation createUser', { email: params.email, username: params.username, userId });
 
-  if (!params.password && !params.plainPassword && !params.webAuthnPublicKeyCredentials) {
+  if (!params.plainPassword && !params.webAuthnPublicKeyCredentials) {
     throw new Error('Password or Public Key is required');
   }
 
   const mappedUser = { ...params };
-  if (!mappedUser.password && mappedUser.plainPassword) {
+  if (mappedUser.plainPassword) {
     mappedUser.password = hashPassword(mappedUser.plainPassword);
   }
   delete mappedUser.plainPassword;

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

@@ -10,7 +10,7 @@ export default async function enrollUser(root: Root, params: UserData, context:
 
   const mappedUserData = params;
   mappedUserData.initialPassword = true;
-  if (!mappedUserData.password && mappedUserData.plainPassword) {
+  if (mappedUserData.plainPassword) {
     mappedUserData.password = hashPassword(mappedUserData.plainPassword);
   }
   delete mappedUserData.plainPassword;

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

@@ -7,24 +7,23 @@ export default async function loginWithPassword(
   params: {
     username?: string;
     email?: string;
-    password?: string;
     plainPassword?: string;
     totpCode?: string;
   },
   context: Context,
 ) {
   const { modules } = context;
-  const { username, email, password: hashedPassword, plainPassword, totpCode } = params;
+  const { username, email, plainPassword, totpCode } = params;
 
   log('mutation loginWithPassword', { username, email });
 
-  if (!hashedPassword && !plainPassword) {
+  if (!plainPassword) {
     throw new Error('Password is required');
   }
 
   const mappedUserLoginParams = {
     user: email ? { email } : { username },
-    password: hashedPassword || hashPassword(plainPassword),
+    password: hashPassword(plainPassword),
     code: totpCode,
   };
 

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

@@ -3,14 +3,14 @@ import { Context, Root } from '@unchainedshop/types/api';
 
 export default async function resetPassword(
   root: Root,
-  params: { newPassword?: string; newPlainPassword?: string; token: string },
+  params: { newPlainPassword?: string; token: string },
   context: Context,
 ) {
   const { modules, userId } = context;
 
   log('mutation resetPassword', { userId });
 
-  if (!params.newPassword && !params.newPlainPassword) {
+  if (!params.newPlainPassword) {
     throw new Error('Password is required');
   }
 

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

@@ -4,7 +4,7 @@ import { UserNotFoundError, InvalidIdError } from '../../../errors';
 
 export default async function setPassword(
   root: Root,
-  params: { newPassword: string; newPlainPassword: string; userId: string },
+  params: { newPlainPassword: string; userId: string },
   { modules, userId }: Context,
 ) {
   const normalizedUserId = params.userId || userId;
@@ -12,7 +12,7 @@ export default async function setPassword(
   log(`mutation setPassword ${normalizedUserId}`, { userId });
 
   if (!normalizedUserId) throw new InvalidIdError({ userId: normalizedUserId });
-  if (!params.newPassword && !params.newPlainPassword) {
+  if (!params.newPlainPassword) {
     throw new Error('Password is required');
   }
   if (!(await modules.users.userExists({ userId: normalizedUserId })))

package/src/resolvers/mutations/assortments/removeAssortment.ts

@@ -14,7 +14,7 @@ export default async function removeAssortment(
   const assortment = await modules.assortments.findAssortment({ assortmentId });
   if (!assortment) throw new AssortmentNotFoundError({ assortmentId });
 
-  await modules.assortments.delete(assortmentId, { skipInvalidation: false }, userId);
+  await modules.assortments.delete(assortmentId, { skipInvalidation: false });
 
   return assortment;
 }

package/src/resolvers/mutations/assortments/removeAssortmentFilter.ts

@@ -18,7 +18,7 @@ export default async function removeAssortmentFilter(
 
   if (!assortmentFilter) throw new AssortmentFilterNotFoundError({ assortmentFilterId });
 
-  await modules.assortments.filters.delete(assortmentFilterId, userId);
+  await modules.assortments.filters.delete(assortmentFilterId);
 
   return assortmentFilter;
 }

package/src/resolvers/mutations/assortments/removeAssortmentLink.ts

@@ -16,7 +16,7 @@ export default async function removeAssortmentLink(
 
   if (!assortmentLink) throw new AssortmentLinkNotFoundError({ assortmentLinkId });
 
-  await modules.assortments.links.delete(assortmentLinkId, { skipInvalidation: false }, userId);
+  await modules.assortments.links.delete(assortmentLinkId, { skipInvalidation: false });
 
   return assortmentLink;
 }

package/src/resolvers/mutations/assortments/removeAssortmentProduct.ts

@@ -18,7 +18,7 @@ export default async function removeAssortmentProduct(
   });
   if (!assortmentProduct) throw new AssortmentProductNotFoundError({ assortmentProductId });
 
-  await modules.assortments.products.delete(assortmentProductId, { skipInvalidation: false }, userId);
+  await modules.assortments.products.delete(assortmentProductId, { skipInvalidation: false });
 
   return assortmentProduct;
 }

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

@@ -15,7 +15,7 @@ export default async function removeFilter(
   const filter = await modules.filters.findFilter({ filterId });
   if (!filter) throw new FilterNotFoundError({ filterId });
 
-  await modules.assortments.filters.deleteMany({ filterId }, userId);
+  await modules.assortments.filters.deleteMany({ filterId });
   await modules.filters.delete(filterId, userId);
 
   return filter;

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/mutations/pageView.ts

@@ -1,10 +1,10 @@
 import { log } from '@unchainedshop/logger';
 import { emit } from '@unchainedshop/events';
 
-export default (root, { path, referrer }, { userId }) => {
+export default async (root, { path, referrer }, { userId }) => {
   log(`mutation pageView ${path} ${referrer}`, { userId });
 
-  emit('PAGE_VIEW', {
+  await emit('PAGE_VIEW', {
     path,
     referrer,
   });

package/src/resolvers/mutations/products/removeProduct.ts

@@ -1,23 +1,21 @@
 import { log } from '@unchainedshop/logger';
 import { Context, Root } from '@unchainedshop/types/api';
-import { ProductNotFoundError, ProductWrongStatusError, InvalidIdError } from '../../../errors';
+import { ProductNotFoundError, InvalidIdError } from '../../../errors';
 
 export default async function removeProduct(
   root: Root,
   { productId }: { productId: string },
-  { modules, userId }: Context,
+  context: Context,
 ) {
+  const { modules, services, userId } = context;
   log(`mutation removeProduct ${productId}`, { userId });
 
   if (!productId) throw new InvalidIdError({ productId });
 
-  const product = await modules.products.findProduct({ productId });
-  if (!product) throw new ProductNotFoundError({ productId });
+  if (!(await modules.products.productExists({ productId })))
+    throw new ProductNotFoundError({ productId });
 
-  if (!modules.products.isDraft(product)) throw new ProductWrongStatusError({ status: product.status });
-
-  await modules.assortments.products.delete(productId as string, {}, userId);
-  await modules.products.delete(productId, userId);
+  await services.products.removeProduct({ productId, userId: context.userId }, context);
 
   return modules.products.findProduct({ productId });
 }

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-path-link-types.ts

@@ -9,9 +9,6 @@ type HelperType<P, T> = (assortmentPathLink: AssortmentPathLinkType, params: P,
 
 export interface AssortmentPathLinkHelperTypes {
   link: HelperType<never, Promise<AssortmentLinkType>>;
-
-  assortmentSlug: HelperType<{ forceLocale?: string }, Promise<string>>;
-
   assortmentTexts: HelperType<{ forceLocale?: string }, Promise<AssortmentText>>;
 }
 
@@ -23,14 +20,6 @@ export const AssortmentPathLink: AssortmentPathLinkHelperTypes = {
     });
   },
 
-  assortmentSlug: async ({ assortmentId }, params, { loaders, localeContext }) => {
-    const text = await loaders.assortmentTextLoader.load({
-      assortmentId,
-      locale: params.forceLocale || localeContext.normalized,
-    });
-    return text.slug;
-  },
-
   assortmentTexts: async ({ assortmentId }, params, { loaders, localeContext }) => {
     const text = await loaders.assortmentTextLoader.load({
       assortmentId,

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/user-types.ts

@@ -16,7 +16,6 @@ import {
   WebAuthnCredentials,
 } from '@unchainedshop/types/user';
 import type { Locale } from 'locale';
-import { log, LogLevel } from '@unchainedshop/logger';
 import { TokenSurrogate } from '@unchainedshop/types/warehousing';
 import { checkAction, checkTypeResolver } from '../../acl';
 import { actions } from '../../roles';
@@ -29,10 +28,8 @@ export interface UserHelperTypes {
   bookmarks: HelperType<any, Array<Bookmark>>;
   cart: HelperType<{ orderNumber?: string }, Order>;
   country: HelperType<{ localeContext: Locale }, Country>;
-  email: HelperType<any, string>;
   emails: HelperType<any, Array<string>>;
   enrollments: HelperType<{ sort?: Array<SortOption>; queryString?: string }, Array<Enrollment>>;
-  isEmailVerified: HelperType<any, boolean>;
   isGuest: HelperType<any, boolean>;
   isInitialPassword: HelperType<any, boolean>;
   isTwoFactorEnabled: HelperType<any, boolean>;
@@ -97,18 +94,6 @@ export const User: UserHelperTypes = {
     return getPrimaryEmail(user);
   },
 
-  email: async (user, params, context) => {
-    await checkAction(context, viewUserPrivateInfos, [user, params]);
-    return getPrimaryEmail(user)?.address;
-  },
-
-  isEmailVerified: async (user, params, context) => {
-    await checkAction(context, viewUserPrivateInfos, [user, params]);
-    log('user.isEmailVerified is deprecated, please use user.primaryEmail.verified', {
-      level: LogLevel.Warning,
-    });
-    return !!getPrimaryEmail(user)?.verified;
-  },
   isInitialPassword: async (user, params, context) => {
     await checkAction(context, viewUserPrivateInfos, [user, params]);
     const { password: { initial } = { initial: undefined } } = user.services || {};

package/src/schema/directives.js

@@ -0,0 +1,14 @@
+export default [
+  /* GraphQL */ `
+    enum CacheControlScope {
+      PUBLIC
+      PRIVATE
+    }
+
+    directive @cacheControl(
+      maxAge: Int
+      scope: CacheControlScope
+      inheritMaxAge: Boolean
+    ) on FIELD_DEFINITION | OBJECT | INTERFACE | UNION
+  `,
+];

package/src/schema/index.js

@@ -1,7 +1,8 @@
 import scalars from './scalars';
+import directives from './directives';
 import types from './types';
 import inputTypes from './inputTypes';
 import query from './query';
 import mutation from './mutation';
 
-export default [...scalars, ...types, ...inputTypes, ...query, ...mutation];
+export default [...scalars, ...directives, ...types, ...inputTypes, ...query, ...mutation];

package/src/schema/inputTypes.js

@@ -1,20 +1,5 @@
 export default [
   /* GraphQL */ `
-    """
-    A hashed password
-    """
-    input HashedPasswordInput {
-      """
-      The hashed password
-      """
-      digest: String!
-
-      """
-      Algorithm used to hash the password
-      """
-      algorithm: String!
-    }
-
     input SortOptionInput {
       key: String!
       value: SortDirection!