@unchainedshop/api 1.2.40 → 2.0.0-beta1

package/src/resolvers/mutations/warehousing/exportToken.ts

@@ -0,0 +1,33 @@
+import { Context, Root } from '@unchainedshop/types/api';
+import { log } from '@unchainedshop/logger';
+import { InvalidIdError } from '../../../errors';
+
+export default async function exportToken(
+  root: Root,
+  {
+    tokenId,
+    quantity,
+    recipientWalletAddress,
+  }: { tokenId: string; quantity: number; recipientWalletAddress: string },
+  { modules, userId }: Context,
+) {
+  log(`mutation exportToken ${tokenId}`, {
+    userId,
+  });
+
+  if (!tokenId) throw new InvalidIdError({ tokenId });
+
+  const token = await modules.warehousing.findToken({ tokenId });
+
+  await modules.worker.addWork({
+    type: 'EXPORT_TOKEN',
+    retries: 5,
+    input: {
+      token,
+      quantity,
+      recipientWalletAddress,
+    },
+  });
+
+  return modules.warehousing.findToken({ tokenId });
+}

package/src/resolvers/queries/{index.js → index.ts}

@@ -61,6 +61,7 @@ import warehousingInterfaces from './warehousing/warehousingInterfaces';
 import warehousingProvider from './warehousing/warehousingProvider';
 import warehousingProviders from './warehousing/warehousingProviders';
 import warehousingProvidersCount from './warehousing/warehousingProvidersCount';
+import token from './warehousing/token';
 import work from './worker/work';
 import workQueue from './worker/workQueue';
 import workQueueCount from './worker/workQueueCount';
@@ -95,6 +96,7 @@ export default {
   warehousingProviders: acl(actions.viewWarehousingProviders)(warehousingProviders),
   warehousingProvider: acl(actions.viewWarehousingProvider)(warehousingProvider),
   warehousingInterfaces: acl(actions.viewWarehousingInterfaces)(warehousingInterfaces),
+  token: acl(actions.viewToken)(token),
   translatedProductTexts: acl(actions.viewTranslations)(translatedProductTexts),
   translatedProductMediaTexts: acl(actions.viewTranslations)(translatedProductMediaTexts),
   translatedProductVariationTexts: acl(actions.viewTranslations)(translatedProductVariationTexts),

package/src/resolvers/queries/warehousing/token.ts

@@ -0,0 +1,17 @@
+import { log } from '@unchainedshop/logger';
+import { Context, Root } from '@unchainedshop/types/api';
+import { InvalidIdError } from '../../../errors';
+
+export default async function token(
+  root: Root,
+  { tokenId }: { tokenId: string },
+  { modules, userId }: Context,
+) {
+  log(`query token ${tokenId}`, { userId });
+
+  if (!tokenId) throw new InvalidIdError({ tokenId });
+
+  return modules.warehousing.findToken({
+    tokenId,
+  });
+}

package/src/resolvers/scalars/LowerCaseString.ts

@@ -0,0 +1,19 @@
+import { GraphQLScalarType, Kind } from 'graphql';
+
+const LowerCaseString = new GraphQLScalarType({
+  name: 'LowerCaseString',
+  description: 'Lowercased string',
+  serialize: (value: any) => value?.toLowerCase(),
+  parseValue(value) {
+    return String(value)?.toLowerCase();
+  },
+  parseLiteral(ast) {
+    if (ast.kind === Kind.STRING) {
+      return ast.value?.toLowerCase();
+    }
+
+    return null;
+  },
+});
+
+export default LowerCaseString;

package/src/resolvers/scalars/index.ts

@@ -0,0 +1,5 @@
+import LowerCaseString from './LowerCaseString';
+
+export default {
+  LowerCaseString,
+};

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

@@ -4,7 +4,7 @@ import { Filter } from '@unchainedshop/types/filters';
 
 type HelperType<T> = (assortmentFilter: AssortmentFilterType, _: never, context: Context) => T;
 
-type AssortmentFilterHelperTypes = {
+export type AssortmentFilterHelperTypes = {
   assortment: HelperType<Promise<Assortment>>;
   filter: HelperType<Promise<Filter>>;
 };

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

@@ -3,7 +3,7 @@ import { Assortment, AssortmentLink as AssortmentLinkType } from '@unchainedshop
 
 type HelperType<T> = (assortmentLink: AssortmentLinkType, _: never, context: Context) => T;
 
-type AssortmentLinkHelperTypes = {
+export type AssortmentLinkHelperTypes = {
   child: HelperType<Promise<Assortment>>;
   parent: HelperType<Promise<Assortment>>;
 };

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

@@ -7,7 +7,7 @@ import { Product } from '@unchainedshop/types/products';
 
 type HelperType<T> = (assortmentProduct: AssortmentProductType, _: never, context: Context) => T;
 
-type AssortmentProductHelperTypes = {
+export type AssortmentProductHelperTypes = {
   assortment: HelperType<Promise<Assortment>>;
   product: HelperType<Promise<Product>>;
 };

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

@@ -0,0 +1,5 @@
+export const Currency = {
+  decimals: (currency) => {
+    return currency.decimals ?? 2;
+  },
+};

package/src/resolvers/type/{index.js → index.ts}

@@ -9,6 +9,7 @@ import { BundleProduct } from './product/product-bundle-types';
 import { Color } from './color-types';
 import { ConfigurableProduct } from './product/product-configurable-types';
 import { Country } from './country-types';
+import { Currency } from './currency-types';
 import { DeliveryProvider } from './delivery-provider-types';
 import { Dimensions } from './dimensions-types';
 import { Dispatch } from './dispatch-types';
@@ -56,12 +57,15 @@ import { ProductVariationOption } from './product/product-variation-option-types
 import { Quotation } from './quotation-types';
 import { Shop } from './shop-types';
 import { SimpleProduct } from './product/product-simple-types';
+import { TokenizedProduct } from './product/product-tokenized-types';
 import { Stock } from './stock-types';
 import { User } from './user-types';
+import { WebAuthnCredentials } from './webauthn-credentials-types';
 import { WarehousingProvider } from './warehousing-provider-types';
 import { Work } from './work-types';
 import { Event } from './event-types';
 import { Media } from './media-types';
+import { Token } from './token-types';
 
 const types = {
   Assortment,
@@ -75,6 +79,7 @@ const types = {
   Color,
   ConfigurableProduct,
   Country,
+  Currency,
   DeliveryProvider,
   Dimensions,
   Dispatch,
@@ -122,8 +127,11 @@ const types = {
   Quotation,
   Shop,
   SimpleProduct,
+  TokenizedProduct,
+  Token,
   Stock,
   User,
+  WebAuthnCredentials,
   WarehousingProvider,
   Work,
   Event,

package/src/resolvers/type/login-method-response-types.ts

@@ -10,4 +10,8 @@ export const LoginMethodResponse = {
 
     return user;
   },
+  token({ token, tokenExpires }, _, { setLoginToken }: Context) {
+    setLoginToken(token, tokenExpires);
+    return token;
+  },
 };

package/src/resolvers/type/order/order-delivery-discount-types.ts

@@ -6,7 +6,7 @@ import crypto from 'crypto';
 
 type HelperType<P, T> = (orderDelivery: OrderDeliveryDiscountType, params: P, context: Context) => T;
 
-interface OrderDeliveryDiscountHelperTypes {
+export interface OrderDeliveryDiscountHelperTypes {
   _id: HelperType<never, string>;
   orderDiscount: HelperType<never, Promise<OrderDiscount>>;
   total: HelperType<never, OrderPrice>;

package/src/resolvers/type/order/order-delivery-shipping-types.ts

@@ -5,7 +5,7 @@ import { OrderDelivery, OrderDeliveryDiscount } from '@unchainedshop/types/order
 
 type HelperType<T> = (orderDelivery: OrderDelivery, _: never, context: Context) => T;
 
-interface OrderDeliveryShippingHelperTypes {
+export interface OrderDeliveryShippingHelperTypes {
   address: HelperType<Address>;
   discounts: HelperType<Promise<Array<OrderDeliveryDiscount>>>;
   provider: HelperType<Promise<DeliveryProvider>>;

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

@@ -6,7 +6,7 @@ import { OrderDiscountDirector } from '@unchainedshop/core-orders';
 
 type HelperType<P, T> = (orderDiscount: OrderDiscountType, params: P, context: Context) => T;
 
-interface OrderDiscountHelperTypes {
+export interface OrderDiscountHelperTypes {
   interface: HelperType<
     never,
     Promise<{

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

@@ -5,7 +5,7 @@ import { OrderPayment } from '@unchainedshop/types/orders.payments';
 import { OrderPosition } from '@unchainedshop/types/orders.positions';
 import { OrderPrice } from '@unchainedshop/types/orders.pricing';
 
-const OrderDiscountableType = {
+export const OrderDiscountableType = {
   OrderItemDiscount: 'OrderItemDiscount',
   OrderPaymentDiscount: 'OrderPaymentDiscount',
   OrderDeliveryDiscount: 'OrderDeliveryDiscount',

package/src/resolvers/type/order/order-global-discount-types.ts

@@ -13,7 +13,7 @@ type HelperType<P, T> = (
   context: Context,
 ) => T;
 
-interface OrderGlobalDiscountHelperTypes {
+export interface OrderGlobalDiscountHelperTypes {
   _id: HelperType<never, string>;
   orderDiscount: HelperType<never, Promise<OrderDiscount>>;
   total: HelperType<never, OrderPrice>;

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

@@ -6,7 +6,7 @@ import crypto from 'crypto';
 
 type HelperType<P, T> = (orderPositionDiscount: OrderPositionDiscount, params: P, context: Context) => T;
 
-interface OrderItemDiscountHelperTypes {
+export interface OrderItemDiscountHelperTypes {
   _id: HelperType<never, string>;
   orderDiscount: HelperType<never, Promise<OrderDiscount>>;
   total: HelperType<never, OrderPrice>;

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

@@ -10,7 +10,7 @@ import crypto from 'crypto';
 
 type HelperType<P, T> = (orderPosition: OrderPosition, params: P, context: Context) => T;
 
-interface OrderItemHelperTypes {
+export interface OrderItemHelperTypes {
   discounts: HelperType<never, Promise<Array<OrderPositionDiscount>>>;
   dispatches: HelperType<
     never,

package/src/resolvers/type/order/order-payment-card-types.ts

@@ -4,7 +4,7 @@ import { PaymentProvider } from '@unchainedshop/types/payments';
 
 type HelperType<T> = (orderPayment: OrderPayment, _: never, context: Context) => T;
 
-interface OrderPaymentCardHelperTypes {
+export interface OrderPaymentCardHelperTypes {
   discounts: HelperType<Promise<Array<OrderPaymentDiscount>>>;
   provider: HelperType<Promise<PaymentProvider>>;
   status: HelperType<string>;

package/src/resolvers/type/order/order-payment-discount-types.ts

@@ -10,7 +10,7 @@ type HelperType<P, T> = (
   context: Context,
 ) => T;
 
-interface OrderPaymentDiscountHelperTypes {
+export interface OrderPaymentDiscountHelperTypes {
   _id: HelperType<never, string>;
   orderDiscount: HelperType<never, Promise<OrderDiscount>>;
   total: HelperType<never, OrderPrice>;

package/src/resolvers/type/order/order-payment-generic-types.ts

@@ -4,7 +4,7 @@ import { PaymentProvider } from '@unchainedshop/types/payments';
 
 type HelperType<P, T> = (orderPayment: OrderPayment, params: P, context: Context) => T;
 
-interface OrderPaymentGenericHelperTypes {
+export interface OrderPaymentGenericHelperTypes {
   discounts: HelperType<never, Promise<Array<OrderPaymentDiscount>>>;
   provider: HelperType<never, Promise<PaymentProvider>>;
   status: HelperType<never, string>;

package/src/resolvers/type/order/order-payment-invoice-types.ts

@@ -4,7 +4,7 @@ import { PaymentProvider } from '@unchainedshop/types/payments';
 
 type HelperType<T> = (orderPayment: OrderPayment, _: never, context: Context) => T;
 
-interface OrderPaymentInvoiceHelperTypes {
+export interface OrderPaymentInvoiceHelperTypes {
   discounts: HelperType<Promise<Array<OrderPaymentDiscount>>>;
   provider: HelperType<Promise<PaymentProvider>>;
   status: HelperType<string>;

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

@@ -3,8 +3,7 @@ import { Country } from '@unchainedshop/types/countries';
 import { Currency } from '@unchainedshop/types/currencies';
 import { DeliveryProvider } from '@unchainedshop/types/delivery';
 import { Enrollment } from '@unchainedshop/types/enrollments';
-import { File } from '@unchainedshop/types/files';
-import { Order as OrderType, OrderDocumentType } from '@unchainedshop/types/orders';
+import { Order as OrderType } from '@unchainedshop/types/orders';
 import { OrderDelivery } from '@unchainedshop/types/orders.deliveries';
 import { OrderDiscount } from '@unchainedshop/types/orders.discounts';
 import { OrderPayment } from '@unchainedshop/types/orders.payments';
@@ -16,14 +15,13 @@ import crypto from 'crypto';
 
 type HelperType<P, T> = (order: OrderType, params: P, context: Context) => T;
 
-interface OrderHelperTypes {
+export interface OrderHelperTypes {
   supportedDeliveryProviders: HelperType<never, Promise<Array<DeliveryProvider>>>;
   supportedPaymentProviders: HelperType<never, Promise<Array<PaymentProvider>>>;
   currency: HelperType<never, Promise<Currency>>;
   country: HelperType<never, Promise<Country>>;
   discounts: HelperType<never, Promise<Array<OrderDiscount>>>;
   delivery: HelperType<never, Promise<OrderDelivery>>;
-  documents: HelperType<{ type: OrderDocumentType }, Promise<Array<File>>>;
   enrollment: HelperType<never, Promise<Enrollment>>;
   payment: HelperType<never, Promise<OrderPayment>>;
   items: HelperType<never, Promise<Array<OrderPosition>>>;
@@ -55,12 +53,6 @@ export const Order: OrderHelperTypes = {
   discounts: async (obj, _, { modules }) =>
     modules.orders.discounts.findOrderDiscounts({ orderId: obj._id }),
 
-  documents: async (obj, { type }, { modules }) =>
-    modules.files.findFilesByMetaData(
-      { meta: { orderId: obj._id, type } },
-      { sort: { 'meta.data': -1 } },
-    ),
-
   delivery: async (obj, _, { modules }) =>
     modules.orders.deliveries.findDelivery({
       orderDeliveryId: obj.deliveryId,

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

@@ -0,0 +1,34 @@
+import { TokenizedProductHelperTypes } from '@unchainedshop/types/products';
+import localePkg from 'locale';
+import { PlanProduct } from './product-plan-types';
+
+const { Locale } = localePkg;
+
+export const TokenizedProduct: TokenizedProductHelperTypes = {
+  ...PlanProduct,
+
+  contractAddress(product) {
+    return product.tokenization?.contractAddress;
+  },
+
+  contractConfiguration(product) {
+    if (!product.tokenization) return null;
+    return {
+      supply: product.tokenization.supply,
+      tokenId: product.tokenization.tokenId,
+    };
+  },
+
+  contractStandard(product) {
+    return product.tokenization?.contractStandard;
+  },
+
+  async ercMetadata(product, { forceLocale }, context) {
+    const locale = forceLocale ? new Locale(forceLocale) : context.localeContext;
+    return context.services.products.ercMetadata({ product, locale }, context);
+  },
+};
+
+delete TokenizedProduct.salesUnit;
+delete TokenizedProduct.salesQuantityPerUnit;
+delete TokenizedProduct.defaultOrderQuantity;

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

@@ -4,14 +4,12 @@ import { User } from '@unchainedshop/types/user';
 import { Product } from '@unchainedshop/types/products';
 import { Country } from '@unchainedshop/types/countries';
 import { Currency } from '@unchainedshop/types/currencies';
-import { File } from '@unchainedshop/types/files';
 
 type HelperType<P, T> = (quotation: QuotationType, params: P, context: Context) => T;
 
 type QuotationHelperTypes = {
   country: HelperType<never, Promise<Country>>;
   currency: HelperType<never, Promise<Currency>>;
-  documents: HelperType<{ type: string }, Promise<Array<File>>>;
   isExpired: HelperType<{ referenceDate: Date }, boolean>;
   status: HelperType<never, string>;
   product: HelperType<never, Promise<Product>>;
@@ -23,21 +21,6 @@ export const Quotation: QuotationHelperTypes = {
 
   currency: async (obj, _, { modules }) => modules.currencies.findCurrency({ isoCode: obj.currency }),
 
-  documents: (obj, { type }, { modules }) =>
-    modules.files.findFilesByMetaData(
-      {
-        meta: {
-          quotationId: obj._id,
-          type,
-        },
-      },
-      {
-        sort: {
-          'meta.date': -1,
-        },
-      },
-    ),
-
   isExpired: (obj, { referenceDate }, { modules }) =>
     modules.quotations.isExpired(obj, { referenceDate }),
 

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

@@ -6,7 +6,7 @@ import { allRoles, actions } from '../../roles';
 
 type HelperType<T> = (root: never, params: never, context: Context) => Promise<T>;
 
-interface ShopHelperTypes {
+export interface ShopHelperTypes {
   _id: () => string;
   country: HelperType<Country>;
   language: HelperType<Language>;

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

@@ -0,0 +1,43 @@
+import { Context } from '@unchainedshop/types/api';
+import { Product } from '@unchainedshop/types/products';
+import { User } from '@unchainedshop/types/user';
+import { TokenSurrogate } from '@unchainedshop/types/warehousing';
+import { WorkStatus } from '@unchainedshop/types/worker';
+
+type HelperType<T> = (root: TokenSurrogate, params: never, context: Context) => Promise<T>;
+
+export enum TokenExportStatus {
+  CENTRALIZED = 'CENTRALIZED',
+  EXPORTING = 'EXPORTING',
+  DECENTRALIZED = 'DECENTRALIZED',
+}
+
+export interface TokenHelperTypes {
+  product: HelperType<Product>;
+  status: HelperType<TokenExportStatus>;
+  user: HelperType<User>;
+}
+
+export const Token: TokenHelperTypes = {
+  product: async (token, _params, { modules }) => {
+    return modules.products.findProduct({ productId: token.productId });
+  },
+
+  user: async (token, _params, { modules }) => {
+    if (!token.userId) return null;
+    return modules.users.findUserById(token.userId);
+  },
+
+  status: async (token, _params, { modules }) => {
+    if (token.walletAddress && !token.userId) {
+      return TokenExportStatus.DECENTRALIZED;
+    }
+    const workItems = await modules.worker.findWorkQueue({
+      types: ['EXPORT_TOKEN'],
+      status: [WorkStatus.NEW, WorkStatus.ALLOCATED],
+    });
+    if (workItems.find((item) => item.input?.token?._id === token._id))
+      return TokenExportStatus.EXPORTING;
+    return TokenExportStatus.CENTRALIZED;
+  },
+};

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

@@ -8,9 +8,10 @@ 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 { Email, User as UserType, UserProfile, 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';
 
@@ -41,6 +42,8 @@ export interface UserHelperTypes {
     Array<Order>
   >;
   paymentCredentials: HelperType<any, Array<PaymentCredentials>>;
+  tokens: HelperType<any, Array<TokenSurrogate>>;
+  webAuthnCredentials: HelperType<any, Array<WebAuthnCredentials>>;
   primaryEmail: HelperType<any, Email>;
   profile: HelperType<any, UserProfile>;
   quotations: HelperType<{ sort?: Array<SortOption>; queryString?: string }, Array<Quotation>>;
@@ -132,6 +135,11 @@ export const User: UserHelperTypes = {
     return modules.orders.cart({ countryContext, orderNumber: params.orderNumber }, user);
   },
 
+  async tokens(user, params, context) {
+    await checkAction(context, viewUserPrivateInfos, [user, params]);
+    return context.modules.warehousing.findTokens({ userId: user._id });
+  },
+
   country: async (user, params, context) => {
     await checkAction(context, viewUserPrivateInfos, [user, params]);
     return context.services.users.getUserCountry(user, params, context);
@@ -181,6 +189,11 @@ export const User: UserHelperTypes = {
     );
   },
 
+  webAuthnCredentials: async (user, params, context) => {
+    await checkAction(context, viewUserPrivateInfos, [user, params]);
+    return user.services.webAuthn || [];
+  },
+
   quotations: async (user, params, context) => {
     await checkAction(context, viewUserQuotations, [user, params]);
     return context.modules.quotations.findQuotations({

package/src/resolvers/type/webauthn-credentials-types.ts

@@ -0,0 +1,27 @@
+import { Context } from '@unchainedshop/types/api';
+import { WebAuthnCredentials as WebAuthnCredentialsTypes } from '@unchainedshop/types/user';
+
+type HelperType<P, T> = (
+  credentials: WebAuthnCredentialsTypes,
+  params: P,
+  context: Context,
+) => Promise<T>;
+
+export interface WebAuthnCredentialsHelperTypes {
+  _id: HelperType<any, string>;
+  created: HelperType<any, Date>;
+  mdsMetadata: HelperType<any, any>;
+}
+
+export const WebAuthnCredentials: WebAuthnCredentialsHelperTypes = {
+  async _id(obj) {
+    return obj.id;
+  },
+  async created(obj) {
+    return obj.created || new Date(0);
+  },
+  async mdsMetadata(obj, _, { modules }) {
+    const metadata = await modules.accounts.webAuthn.findMDSMetadataForAAGUID(obj.aaguid);
+    return metadata;
+  },
+};

package/src/roles/admin.ts

@@ -23,6 +23,8 @@ export const admin = (role, actions) => {
   role.allow(actions.managePaymentProviders, () => true);
   role.allow(actions.manageDeliveryProviders, () => true);
   role.allow(actions.manageWarehousingProviders, () => true);
+  role.allow(actions.updateToken, () => true);
+  role.allow(actions.viewToken, () => true);
   role.allow(actions.manageUsers, () => true);
   role.allow(actions.updateUser, () => true);
   role.allow(actions.updateUsername, () => true);
@@ -47,6 +49,7 @@ export const admin = (role, actions) => {
   role.allow(actions.viewUserPublicInfos, () => true);
   role.allow(actions.viewUserPrivateInfos, () => true);
   role.allow(actions.viewUserEnrollments, () => true);
+  role.allow(actions.viewUserTokens, () => true);
   role.allow(actions.reviewProduct, () => true);
   role.allow(actions.updateProductReview, () => true);
   role.allow(actions.manageProductReviews, () => true);

package/src/roles/all.ts

@@ -31,6 +31,8 @@ export const all = (role, actions) => {
   role.allow(actions.managePaymentProviders, () => false);
   role.allow(actions.manageDeliveryProviders, () => false);
   role.allow(actions.manageWarehousingProviders, () => false);
+  role.allow(actions.updateToken, () => false);
+  role.allow(actions.viewToken, () => false);
   role.allow(actions.manageAssortments, () => false);
   role.allow(actions.manageFilters, () => false);
   role.allow(actions.manageUsers, () => false);
@@ -49,6 +51,7 @@ export const all = (role, actions) => {
   role.allow(actions.viewLogs, isInLoginMutationResponse);
   role.allow(actions.viewUserRoles, isInLoginMutationResponse);
   role.allow(actions.viewUserOrders, isInLoginMutationResponse);
+  role.allow(actions.viewUserTokens, isInLoginMutationResponse);
   role.allow(actions.viewUserQuotations, isInLoginMutationResponse);
   role.allow(actions.viewUserPrivateInfos, isInLoginMutationResponse);
   role.allow(actions.viewUserEnrollments, isInLoginMutationResponse);

package/src/roles/index.ts

@@ -12,7 +12,7 @@ const roles = {
 
 const allRoles = roles;
 
-const actions = [
+const actions: Record<string, string> = [
   'viewEvent',
   'viewEvents',
   'viewUserRoles',
@@ -21,6 +21,7 @@ const actions = [
   'viewUserPublicInfos',
   'viewUserPrivateInfos',
   'viewUserEnrollments',
+  'viewUserTokens',
   'viewLogs',
   'viewUser',
   'viewUsers',
@@ -57,6 +58,8 @@ const actions = [
   'managePaymentProviders',
   'manageDeliveryProviders',
   'manageWarehousingProviders',
+  'updateToken',
+  'viewToken',
   'manageAssortments',
   'manageFilters',
   'createCart',

package/src/roles/loggedIn.ts

@@ -190,6 +190,16 @@ export const loggedIn = (role: any, actions: Record<string, string>) => {
     return credentials.userId === userId;
   };
 
+  const isOwnedToken = async (
+    obj: any,
+    { tokenId }: { tokenId: string },
+    { modules, userId }: Context,
+  ) => {
+    const token = await modules.warehousing.findToken({ tokenId });
+    if (!token) return true;
+    return token.userId === userId;
+  };
+
   role.allow(actions.viewEvent, false);
   role.allow(actions.viewEvents, false);
   role.allow(actions.viewUser, isMyself);
@@ -198,6 +208,7 @@ export const loggedIn = (role: any, actions: Record<string, string>) => {
   role.allow(actions.viewUserQuotations, isMyself);
   role.allow(actions.viewUserEnrollments, isMyself);
   role.allow(actions.viewUserPrivateInfos, isMyself);
+  role.allow(actions.viewUserTokens, isMyself);
   role.allow(actions.updateUser, isMyself);
   role.allow(actions.authTwoFactor, isMyself);
   role.allow(actions.manageTwoFactor, isMyself);
@@ -223,4 +234,6 @@ export const loggedIn = (role: any, actions: Record<string, string>) => {
   role.allow(actions.voteProductReview, () => true);
   role.allow(actions.registerPaymentCredentials, () => true);
   role.allow(actions.managePaymentCredentials, isOwnedPaymentCredential);
+  role.allow(actions.updateToken, isOwnedToken);
+  role.allow(actions.viewToken, isOwnedToken);
 };