@unchainedshop/api 1.1.3

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

@@ -0,0 +1,194 @@
+import { Context } from '@unchainedshop/types/api';
+import { Bookmark } from '@unchainedshop/types/bookmarks';
+import { Contact } from '@unchainedshop/types/common';
+import { Country } from '@unchainedshop/types/countries';
+import { Enrollment } from '@unchainedshop/types/enrollments';
+import { File } from '@unchainedshop/types/files';
+import { Language } from '@unchainedshop/types/languages';
+import { Order } from '@unchainedshop/types/orders';
+import { PaymentCredentials } from '@unchainedshop/types/payments';
+import { Quotation } from '@unchainedshop/types/quotations';
+import { Email, User as UserType, UserProfile } from '@unchainedshop/types/user';
+import { Locale } from 'locale';
+import { log, LogLevel } from '@unchainedshop/logger';
+import { checkAction, checkTypeResolver } from '../../acl';
+import { actions } from '../../roles';
+
+type HelperType<P, T> = (user: UserType, params: P, context: Context) => Promise<T>;
+
+export interface UserHelperTypes {
+  _id: HelperType<any, boolean>;
+  avatar: HelperType<{ localeContext: Locale }, File>;
+  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<any, Array<Enrollment>>;
+  isEmailVerified: HelperType<any, boolean>;
+  isGuest: HelperType<any, boolean>;
+  isInitialPassword: HelperType<any, boolean>;
+  isTwoFactorEnabled: HelperType<any, boolean>;
+  language: HelperType<{ localeContext: Locale }, Language>;
+  lastBillingAddress: HelperType<any, UserType['lastBillingAddress']>;
+  lastContact: HelperType<any, Contact>;
+  lastLogin: HelperType<any, UserType['lastLogin']>;
+  allowedActions: HelperType<any, Array<string>>;
+  // locale: HelperType<{ localeContext: Locale }, Locale>;
+  name: HelperType<any, string>;
+  orders: HelperType<{ includeCarts: boolean }, Array<Order>>;
+  paymentCredentials: HelperType<any, Array<PaymentCredentials>>;
+  primaryEmail: HelperType<any, Email>;
+  profile: HelperType<any, UserProfile>;
+  quotations: HelperType<any, Array<Quotation>>;
+  roles: HelperType<any, Array<string>>;
+  tags: HelperType<any, Array<string>>;
+  username: HelperType<any, string>;
+}
+
+const {
+  viewUserPrivateInfos,
+  viewUserPublicInfos,
+  viewUserOrders,
+  viewUserEnrollments,
+  viewUserQuotations,
+} = actions as Record<string, string>;
+
+const getPrimaryEmail = (user: UserType) => {
+  return (user.emails || []).sort((left, right) => Number(right.verified) - Number(left.verified))?.[0];
+};
+
+export const User: UserHelperTypes = {
+  _id: checkTypeResolver(viewUserPublicInfos, '_id'),
+  emails: checkTypeResolver(viewUserPrivateInfos, 'emails'),
+  lastBillingAddress: checkTypeResolver(viewUserPrivateInfos, 'lastBillingAddress'),
+  lastContact: checkTypeResolver(viewUserPrivateInfos, 'lastContact'),
+  lastLogin: checkTypeResolver(viewUserPrivateInfos, 'lastLogin'),
+  profile: checkTypeResolver(viewUserPrivateInfos, 'profile'),
+  roles: checkTypeResolver(viewUserPrivateInfos, 'roles'),
+  tags: checkTypeResolver(viewUserPrivateInfos, 'tags'),
+  username: checkTypeResolver(viewUserPrivateInfos, 'username'),
+
+  name: async (user, params, context) => {
+    await checkAction(context, viewUserPublicInfos, [user, params]);
+
+    const { profile } = user;
+    if (profile && profile.displayName && profile.displayName !== '') return profile.displayName;
+
+    const primaryEmail = getPrimaryEmail(user);
+    return primaryEmail?.address || user._id;
+  },
+
+  primaryEmail: async (user, params, context) => {
+    await checkAction(context, viewUserPrivateInfos, [user, params]);
+    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 || {};
+    return user.initialPassword || !!initial;
+  },
+  isTwoFactorEnabled: async (user, params, context) => {
+    await checkAction(context, viewUserPrivateInfos, [user, params]);
+    const { 'two-factor': { secret } = { secret: undefined } } = user.services || {};
+    return !!secret;
+  },
+  isGuest: async (user, params, context) => {
+    await checkAction(context, viewUserPrivateInfos, [user, params]);
+    return !!user.guest;
+  },
+
+  avatar: async (user, params, context) => {
+    await checkAction(context, viewUserPublicInfos, [user, params]);
+    return context.modules.files.findFile({
+      fileId: user.avatarId as string,
+    });
+  },
+
+  bookmarks: async (user, params, context) => {
+    await checkAction(context, viewUserPrivateInfos, [user, params]);
+    return context.modules.bookmarks.findByUserId(user._id);
+  },
+
+  async cart(user, params, context) {
+    const { modules, countryContext } = context;
+    await checkAction(context, viewUserOrders, [user, params]);
+    return modules.orders.cart({ countryContext, orderNumber: params.orderNumber }, user);
+  },
+
+  country: async (user, params, context) => {
+    await checkAction(context, viewUserPrivateInfos, [user, params]);
+    return context.services.users.getUserCountry(user, params, context);
+  },
+
+  enrollments: async (user, params, context) => {
+    await checkAction(context, viewUserEnrollments, [user, params]);
+    return context.modules.enrollments.findEnrollments({
+      userId: user._id,
+    });
+  },
+
+  language: async (user, params, context) => {
+    await checkAction(context, viewUserPrivateInfos, [user, params]);
+    return context.services.users.getUserLanguage(user, params, context);
+  },
+
+  allowedActions: async (user, params, context) => {
+    await checkAction(context, viewUserPrivateInfos, [user, params]);
+    return context.services.users.getUserRoleActions(user, context);
+  },
+
+  // locale: async (user, params, context) => {
+  //   await checkAction(context, viewUserPrivateInfos, [user, params, context]);
+  //   return context.modules.users.userLocale(user, params);
+  // },
+
+  orders: async (user, params, context) => {
+    await checkAction(context, viewUserOrders, [user, params]);
+    return context.modules.orders.findOrders(
+      { userId: user._id, includeCarts: params.includeCarts },
+      {
+        sort: {
+          updated: -1,
+        },
+      },
+    );
+  },
+
+  paymentCredentials: async (user, params, context) => {
+    await checkAction(context, viewUserPrivateInfos, [user, params]);
+    return context.modules.payment.paymentCredentials.findPaymentCredentials(
+      { ...params.selector, userId: user._id },
+      {
+        sort: {
+          created: -1,
+        },
+      },
+    );
+  },
+
+  quotations: async (user, params, context) => {
+    await checkAction(context, viewUserQuotations, [user, params]);
+    return context.modules.quotations.findQuotations(
+      { userId: user._id },
+      {
+        sort: {
+          created: -1,
+        },
+      },
+    );
+  },
+};

package/src/resolvers/type/warehousing-provider-types.ts

@@ -0,0 +1,17 @@
+import { WarehousingProviderHelperTypes } from '@unchainedshop/types/warehousing';
+
+export const WarehousingProvider: WarehousingProviderHelperTypes = {
+  interface(obj, _, context) {
+    const Interface = context.modules.warehousing.findInterface(obj);
+    if (!Interface) return null;
+    return Interface;
+  },
+
+  async configurationError(obj, _, context) {
+    return context.modules.warehousing.configurationError(obj, context);
+  },
+
+  async isActive(obj, _, context) {
+    return context.modules.warehousing.isActive(obj, context);
+  },
+};

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

@@ -0,0 +1,25 @@
+import { Context } from '@unchainedshop/types/api';
+import { Work as WorkType } from '@unchainedshop/types/worker';
+
+type HelperType<P, T> = (work: WorkType, params: P, context: Context) => T;
+
+export interface WorkHelperTypes {
+  status: HelperType<never, string>;
+  type: HelperType<never, string>;
+  original: HelperType<never, Promise<WorkType>>;
+}
+
+export const Work: WorkHelperTypes = {
+  status: (obj, _, { modules }) => {
+    return modules.worker.status(obj);
+  },
+
+  type: (obj, _, { modules }) => {
+    return modules.worker.type(obj);
+  },
+
+  original: async (obj, _, { modules }) => {
+    if (!obj.originalWorkId) return null;
+    return modules.worker.findWork({ workId: obj.originalWorkId });
+  },
+};

package/src/roles/admin.ts

@@ -0,0 +1,71 @@
+export const admin = (role, actions) => {
+  role.allow(actions.viewEvent, () => true);
+  role.allow(actions.viewEvents, () => true);
+  role.allow(actions.viewUser, () => true);
+  role.allow(actions.viewUsers, () => true);
+  role.allow(actions.viewPaymentProviders, () => true);
+  role.allow(actions.viewPaymentProvider, () => true);
+  role.allow(actions.viewPaymentInterfaces, () => true);
+  role.allow(actions.viewDeliveryProviders, () => true);
+  role.allow(actions.viewDeliveryProvider, () => true);
+  role.allow(actions.viewDeliveryInterfaces, () => true);
+  role.allow(actions.viewWarehousingProviders, () => true);
+  role.allow(actions.viewWarehousingProvider, () => true);
+  role.allow(actions.viewWarehousingInterfaces, () => true);
+  role.allow(actions.viewTranslations, () => true);
+  role.allow(actions.viewOrders, () => true);
+  role.allow(actions.viewOrder, () => true);
+  role.allow(actions.viewProducts, () => true);
+  role.allow(actions.manageLanguages, () => true);
+  role.allow(actions.manageCountries, () => true);
+  role.allow(actions.manageProducts, () => true);
+  role.allow(actions.manageCurrencies, () => true);
+  role.allow(actions.managePaymentProviders, () => true);
+  role.allow(actions.manageDeliveryProviders, () => true);
+  role.allow(actions.manageWarehousingProviders, () => true);
+  role.allow(actions.manageUsers, () => true);
+  role.allow(actions.updateUser, () => true);
+  role.allow(actions.updateUsername, () => true);
+  role.allow(actions.manageAssortments, () => true);
+  role.allow(actions.manageFilters, () => true);
+  role.allow(actions.updateCart, () => true);
+  role.allow(actions.createCart, () => true);
+  role.allow(actions.sendEmail, () => true);
+  role.allow(actions.updateOrder, () => true);
+  role.allow(actions.updateOrderDiscount, () => true);
+  role.allow(actions.updateOrderItem, () => true);
+  role.allow(actions.updateOrderDelivery, () => true);
+  role.allow(actions.updateOrderPayment, () => true);
+  role.allow(actions.markOrderConfirmed, () => true);
+  role.allow(actions.markOrderRejected, () => true);
+  role.allow(actions.markOrderPaid, () => true);
+  role.allow(actions.markOrderDelivered, () => true);
+  role.allow(actions.viewLogs, () => true);
+  role.allow(actions.viewUserRoles, () => true);
+  role.allow(actions.viewUserOrders, () => true);
+  role.allow(actions.viewUserQuotations, () => true);
+  role.allow(actions.viewUserPublicInfos, () => true);
+  role.allow(actions.viewUserPrivateInfos, () => true);
+  role.allow(actions.viewUserEnrollments, () => true);
+  role.allow(actions.reviewProduct, () => true);
+  role.allow(actions.updateProductReview, () => true);
+  role.allow(actions.manageProductReviews, () => true);
+  role.allow(actions.requestQuotation, () => true);
+  role.allow(actions.viewQuotations, () => true);
+  role.allow(actions.viewQuotation, () => true);
+  role.allow(actions.manageQuotations, () => true);
+  role.allow(actions.answerQuotation, () => true);
+  role.allow(actions.bookmarkProduct, () => true);
+  role.allow(actions.manageBookmarks, () => true);
+  role.allow(actions.voteProductReview, () => true);
+  role.allow(actions.manageWorker, () => true);
+  role.allow(actions.viewEnrollments, () => true);
+  role.allow(actions.viewEnrollment, () => true);
+  role.allow(actions.updateEnrollment, () => true);
+  role.allow(actions.registerPaymentCredentials, () => true);
+  role.allow(actions.managePaymentCredentials, () => true);
+  role.allow(actions.bulkImport, () => true);
+  role.allow(actions.authTwoFactor, () => true);
+  role.allow(actions.manageTwoFactor, () => true);
+  role.allow(actions.impersonate, () => true);
+};

package/src/roles/all.ts

@@ -0,0 +1,99 @@
+export const all = (role, actions) => {
+  const isInLoginMutationResponse = (root) => {
+    // eslint-disable-next-line
+    if (root && root._inLoginMethodResponse) {
+      return true;
+    }
+    return false;
+  };
+
+  role.allow(actions.viewEvent, () => false);
+  role.allow(actions.viewEvents, () => false);
+  role.allow(actions.viewUser, () => false);
+  role.allow(actions.viewUsers, () => false);
+  role.allow(actions.viewPaymentProviders, () => false);
+  role.allow(actions.viewPaymentProvider, () => false);
+  role.allow(actions.viewPaymentInterfaces, () => false);
+  role.allow(actions.viewDeliveryProviders, () => false);
+  role.allow(actions.viewDeliveryProvider, () => false);
+  role.allow(actions.viewDeliveryInterfaces, () => false);
+  role.allow(actions.viewWarehousingProviders, () => false);
+  role.allow(actions.viewWarehousingProvider, () => false);
+  role.allow(actions.viewWarehousingInterfaces, () => false);
+  role.allow(actions.viewOrders, () => false);
+  role.allow(actions.sendEmail, () => false);
+  role.allow(actions.updateUser, () => false);
+  role.allow(actions.updateUsername, () => false);
+  role.allow(actions.manageLanguages, () => false);
+  role.allow(actions.manageCountries, () => false);
+  role.allow(actions.manageProducts, () => false);
+  role.allow(actions.manageCurrencies, () => false);
+  role.allow(actions.managePaymentProviders, () => false);
+  role.allow(actions.manageDeliveryProviders, () => false);
+  role.allow(actions.manageWarehousingProviders, () => false);
+  role.allow(actions.manageAssortments, () => false);
+  role.allow(actions.manageFilters, () => false);
+  role.allow(actions.manageUsers, () => false);
+  role.allow(actions.updateCart, () => false);
+  role.allow(actions.createCart, () => false);
+  role.allow(actions.checkoutCart, () => false);
+  role.allow(actions.updateOrder, () => false);
+  role.allow(actions.updateOrderDiscount, () => false);
+  role.allow(actions.updateOrderItem, () => false);
+  role.allow(actions.updateOrderDelivery, () => false);
+  role.allow(actions.updateOrderPayment, () => false);
+  role.allow(actions.markOrderConfirmed, () => false);
+  role.allow(actions.markOrderRejected, () => false);
+  role.allow(actions.markOrderPaid, () => false);
+  role.allow(actions.markOrderDelivered, () => false);
+  role.allow(actions.viewLogs, isInLoginMutationResponse);
+  role.allow(actions.viewUserRoles, isInLoginMutationResponse);
+  role.allow(actions.viewUserOrders, isInLoginMutationResponse);
+  role.allow(actions.viewUserQuotations, isInLoginMutationResponse);
+  role.allow(actions.viewUserPrivateInfos, isInLoginMutationResponse);
+  role.allow(actions.viewUserEnrollments, isInLoginMutationResponse);
+  role.allow(actions.reviewProduct, () => false);
+  role.allow(actions.updateProductReview, () => false);
+  role.allow(actions.manageProductReviews, () => false);
+  role.allow(actions.requestQuotation, () => false);
+  role.allow(actions.viewQuotations, () => false);
+  role.allow(actions.manageQuotations, () => false);
+  role.allow(actions.answerQuotation, () => false);
+  role.allow(actions.manageBookmarks, () => false);
+  role.allow(actions.bookmarkProduct, () => false);
+  role.allow(actions.voteProductReview, () => false);
+  role.allow(actions.manageWorker, () => false);
+  role.allow(actions.viewEnrollment, () => false);
+  role.allow(actions.viewEnrollments, () => false);
+  role.allow(actions.updateEnrollment, () => false);
+  role.allow(actions.createEnrollment, () => false);
+  role.allow(actions.registerPaymentCredentials, () => false);
+  role.allow(actions.managePaymentCredentials, () => false);
+  role.allow(actions.bulkImport, () => false);
+  role.allow(actions.viewOrder, () => false);
+  role.allow(actions.viewQuotation, () => false);
+  role.allow(actions.viewEnrollment, () => false);
+  role.allow(actions.authTwoFactor, () => false);
+  role.allow(actions.manageTwoFactor, () => false);
+  role.allow(actions.impersonate, () => false);
+
+  // only allow if query is not demanding for drafts
+  role.allow(actions.viewProducts, (root, { includeDrafts }) => !includeDrafts);
+
+  // public
+  role.allow(actions.viewUserPublicInfos, () => true);
+  role.allow(actions.viewProduct, () => true);
+  role.allow(actions.viewLanguages, () => true);
+  role.allow(actions.viewLanguage, () => true);
+  role.allow(actions.viewCountries, () => true);
+  role.allow(actions.viewCountry, () => true);
+  role.allow(actions.viewCurrencies, () => true);
+  role.allow(actions.viewCurrency, () => true);
+  role.allow(actions.viewShopInfo, () => true);
+  role.allow(actions.viewAssortments, () => true);
+  role.allow(actions.viewAssortment, () => true);
+  role.allow(actions.viewFilter, () => true);
+  role.allow(actions.viewFilters, () => true);
+  role.allow(actions.viewTranslations, () => true);
+  role.allow(actions.search, () => true);
+};

package/src/roles/index.ts

@@ -0,0 +1,124 @@
+import { Roles, Role } from '@unchainedshop/roles';
+
+import { all } from './all';
+import { loggedIn } from './loggedIn';
+import { admin } from './admin';
+
+const roles = {
+  ADMIN: Roles.adminRole,
+  LOGGEDIN: Roles.loggedInRole,
+  ALL: Roles.allRole,
+};
+
+const allRoles = roles;
+
+const actions = [
+  'viewEvent',
+  'viewEvents',
+  'viewUserRoles',
+  'viewUserOrders',
+  'viewUserQuotations',
+  'viewUserPublicInfos',
+  'viewUserPrivateInfos',
+  'viewUserEnrollments',
+  'viewLogs',
+  'viewUser',
+  'viewUsers',
+  'viewProduct',
+  'viewProducts',
+  'viewLanguages',
+  'viewLanguage',
+  'viewCountries',
+  'viewCountry',
+  'viewCurrencies',
+  'viewCurrency',
+  'viewPaymentProviders',
+  'viewPaymentProvider',
+  'viewPaymentInterfaces',
+  'viewDeliveryProviders',
+  'viewDeliveryProvider',
+  'viewDeliveryInterfaces',
+  'viewWarehousingProviders',
+  'viewWarehousingProvider',
+  'viewWarehousingInterfaces',
+  'viewTranslations',
+  'viewOrders',
+  'viewOrder',
+  'viewShopInfo',
+  'updateUser',
+  'updateUsername',
+  'sendEmail',
+  'manageUsers',
+  'manageUsers',
+  'manageLanguages',
+  'manageCountries',
+  'manageProducts',
+  'manageCurrencies',
+  'managePaymentProviders',
+  'manageDeliveryProviders',
+  'manageWarehousingProviders',
+  'manageAssortments',
+  'manageFilters',
+  'createCart',
+  'createEnrollment',
+  'updateEnrollment',
+  'updateCart',
+  'checkoutCart',
+  'updateOrder',
+  'updateOrderDelivery',
+  'updateOrderPayment',
+  'updateOrderDiscount',
+  'updateOrderItem',
+  'markOrderConfirmed',
+  'markOrderRejected',
+  'markOrderPaid',
+  'markOrderDelivered',
+  'viewAssortments',
+  'viewAssortment',
+  'viewFilter',
+  'viewFilters',
+  'reviewProduct',
+  'updateProductReview',
+  'manageProductReviews',
+  'voteProductReview',
+  'requestQuotation',
+  'viewQuotations',
+  'viewQuotation',
+  'manageQuotations',
+  'answerQuotation',
+  'bookmarkProduct',
+  'manageBookmarks',
+  'search',
+  'manageWorker',
+  'viewEnrollments',
+  'viewEnrollment',
+  'registerPaymentCredentials',
+  'managePaymentCredentials',
+  'bulkImport',
+  'authTwoFactor',
+  'manageTwoFactor',
+  'impersonate',
+].reduce((oldValue, actionValue) => {
+  const newValue = oldValue;
+  newValue[actionValue] = actionValue;
+  return newValue;
+}, {});
+
+const configureRoles = ({ additionalRoles = {}, additionalActions = [] }) => {
+  additionalActions.forEach((action) => {
+    actions[action] = action;
+  });
+  Object.entries(additionalRoles).forEach(([key, val]: [string, any]) => {
+    allRoles[key] = new Role(key);
+    val(allRoles[key], actions);
+  });
+  all(allRoles.ALL, actions);
+  loggedIn(allRoles.LOGGEDIN, actions);
+  admin(allRoles.ADMIN, actions);
+
+  return allRoles;
+};
+
+const updateUserRole = (context, roleName) => Roles.addUserToRoles(context, roles[roleName].name);
+
+export { allRoles, actions, configureRoles, updateUserRole };