@unchainedshop/api 2.8.18 → 2.9.0

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

@@ -1,24 +1,62 @@
-import { ConfigurableProductHelperTypes } from '@unchainedshop/types/products.js';
+import {
+  Product as ProductType,
+  ProductAssignment,
+  ProductConfiguration,
+  ProductPriceRange,
+} from '@unchainedshop/types/products.js';
+import { Context } from '@unchainedshop/types/api.js';
+import { ProductVariation } from '@unchainedshop/types/products.variations.js';
 import { Product } from './product-types.js';
 
-export const ConfigurableProduct: ConfigurableProductHelperTypes = {
+export const ConfigurableProduct = {
   ...Product,
 
-  assignments: async (obj, params, { modules }) => {
-    return modules.products.proxyAssignments(obj, params);
+  async assignments(
+    product: ProductType,
+    params: {
+      includeInactive: boolean;
+    },
+    { modules }: Context,
+  ): Promise<
+    Array<{
+      assignment: ProductAssignment;
+      product: typeof product;
+    }>
+  > {
+    return modules.products.proxyAssignments(product, params);
   },
 
-  products: async (obj, { vectors, includeInactive }, { modules }) => {
-    return modules.products.proxyProducts(obj, vectors, {
+  async products(
+    product: ProductType,
+    {
+      vectors,
+      includeInactive,
+    }: {
+      vectors: Array<ProductConfiguration>;
+      includeInactive: boolean;
+    },
+    { modules }: Context,
+  ): Promise<Array<typeof product>> {
+    return modules.products.proxyProducts(product, vectors, {
       includeInactive,
     });
   },
 
-  catalogPriceRange: async (
-    obj,
-    { quantity, vectors, currency: forcedCurrencyCode, includeInactive },
-    requestContext,
-  ) => {
+  async catalogPriceRange(
+    product: ProductType,
+    {
+      quantity,
+      vectors,
+      currency: forcedCurrencyCode,
+      includeInactive,
+    }: {
+      currency?: string;
+      includeInactive: boolean;
+      quantity: number;
+      vectors: Array<ProductConfiguration>;
+    },
+    requestContext: Context,
+  ): Promise<ProductPriceRange> {
     const { countryContext, modules } = requestContext;
     const currencyCode =
       forcedCurrencyCode ||
@@ -28,7 +66,7 @@ export const ConfigurableProduct: ConfigurableProductHelperTypes = {
         },
         requestContext,
       ));
-    return modules.products.prices.catalogPriceRange(obj, {
+    return modules.products.prices.catalogPriceRange(product, {
       quantity,
       vectors,
       includeInactive,
@@ -37,19 +75,41 @@ export const ConfigurableProduct: ConfigurableProductHelperTypes = {
     });
   },
 
-  variations: async (obj, { limit = 10, offset = 0 }, { modules }) => {
+  async variations(
+    product: ProductType,
+    {
+      limit = 10,
+      offset = 0,
+    }: {
+      limit: number;
+      offset: number;
+    },
+    { modules }: Context,
+  ): Promise<Array<ProductVariation>> {
     return modules.products.variations.findProductVariations({
-      productId: obj._id,
+      productId: product._id,
       limit,
       offset,
     });
   },
 
   async simulatedPriceRange(
-    obj,
-    { currency: forcedCurrencyCode, quantity, useNetPrice, vectors, includeInactive },
-    requestContext,
-  ) {
+    product: ProductType,
+    {
+      currency: forcedCurrencyCode,
+      quantity,
+      useNetPrice,
+      vectors,
+      includeInactive,
+    }: {
+      currency?: string;
+      includeInactive: boolean;
+      quantity?: number;
+      vectors: Array<ProductConfiguration>;
+      useNetPrice: boolean;
+    },
+    requestContext: Context,
+  ): Promise<ProductPriceRange> {
     const { countryContext, modules } = requestContext;
     const currency =
       forcedCurrencyCode ||
@@ -60,7 +120,7 @@ export const ConfigurableProduct: ConfigurableProductHelperTypes = {
         requestContext,
       ));
     return modules.products.prices.simulatedPriceRange(
-      obj,
+      product,
       {
         quantity,
         currency,

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

@@ -1,10 +1,15 @@
-import { PlanProductHelperTypes } from '@unchainedshop/types/products.js';
+import { ProductPrice, Product as ProductType } from '@unchainedshop/types/products.js';
+import { Context } from '@unchainedshop/types/api.js';
 import { Product } from './product-types.js';
 
-export const PlanProduct: PlanProductHelperTypes = {
+export const PlanProduct = {
   ...Product,
 
-  catalogPrice: async (product, { quantity, currency: forcedCurrencyCode }, requestContext) => {
+  async catalogPrice(
+    product: ProductType,
+    { quantity, currency: forcedCurrencyCode }: { quantity?: number; currency?: string },
+    requestContext: Context,
+  ): Promise<ProductPrice> {
     const { modules, countryContext } = requestContext;
     const currencyCode =
       forcedCurrencyCode ||
@@ -21,11 +26,15 @@ export const PlanProduct: PlanProductHelperTypes = {
     });
   },
 
-  simulatedPrice: async (
-    obj,
-    { currency: forcedCurrencyCode, quantity, useNetPrice },
-    requestContext,
-  ) => {
+  async simulatedPrice(
+    obj: ProductType,
+    {
+      currency: forcedCurrencyCode,
+      quantity,
+      useNetPrice,
+    }: { quantity?: number; currency?: string; useNetPrice?: boolean },
+    requestContext: Context,
+  ): Promise<ProductPrice> {
     const { countryContext, modules } = requestContext;
     const currency =
       forcedCurrencyCode ||
@@ -42,7 +51,17 @@ export const PlanProduct: PlanProductHelperTypes = {
     );
   },
 
-  leveledCatalogPrices: async (obj, { currency: forcedCurrencyCode }, requestContext) => {
+  async leveledCatalogPrices(
+    obj: ProductType,
+    { currency: forcedCurrencyCode }: { currency?: string },
+    requestContext: Context,
+  ): Promise<
+    Array<{
+      minQuantity: number;
+      maxQuantity: number;
+      price: ProductPrice;
+    }>
+  > {
     const { countryContext, modules } = requestContext;
     const currency =
       forcedCurrencyCode ||
@@ -55,13 +74,13 @@ export const PlanProduct: PlanProductHelperTypes = {
     return modules.products.prices.catalogPricesLeveled(obj, { currency, country: countryContext });
   },
 
-  salesUnit(obj) {
-    return obj.commerce && obj.commerce.salesUnit;
+  salesUnit({ commerce }: ProductType): string {
+    return commerce?.salesUnit;
   },
-  salesQuantityPerUnit(obj) {
-    return obj.commerce && obj.commerce.salesQuantityPerUnit;
+  salesQuantityPerUnit({ commerce }: ProductType): string {
+    return commerce?.salesQuantityPerUnit;
   },
-  defaultOrderQuantity(obj) {
-    return obj.commerce && obj.commerce.defaultOrderQuantity;
+  defaultOrderQuantity({ commerce }: ProductType): number {
+    return commerce?.defaultOrderQuantity;
   },
 };

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

@@ -1,11 +1,26 @@
-import { SimpleProductHelperTypes } from '@unchainedshop/types/products.js';
-import { WarehousingContext } from '@unchainedshop/types/warehousing.js';
+import { Product, ProductSupply } from '@unchainedshop/types/products.js';
+import { WarehousingContext, WarehousingProvider } from '@unchainedshop/types/warehousing.js';
+import { Context } from '@unchainedshop/types/api.js';
+import { DeliveryProviderType } from '@unchainedshop/core-delivery';
+import { DeliveryProvider } from '@unchainedshop/types/delivery.js';
 import { PlanProduct } from './product-plan-types.js';
 
-export const SimpleProduct: SimpleProductHelperTypes = {
+export const SimpleProduct = {
   ...PlanProduct,
 
-  simulatedDispatches: async (obj, params, requestContext) => {
+  async simulatedDispatches(
+    obj: Product,
+    params: { referenceDate: Date; quantity: number; deliveryProviderType: DeliveryProviderType },
+    requestContext: Context,
+  ): Promise<
+    Array<{
+      _id: string;
+      deliveryProvider?: DeliveryProvider;
+      warehousingProvider?: WarehousingProvider;
+      shipping?: Date;
+      earliestDelivery?: Date;
+    }>
+  > {
     const { deliveryProviderType, referenceDate, quantity } = params;
     const { modules } = requestContext;
 
@@ -51,7 +66,21 @@ export const SimpleProduct: SimpleProductHelperTypes = {
     }, Promise.resolve([]));
   },
 
-  simulatedStocks: async (obj, params, requestContext) => {
+  async simulatedStocks(
+    obj: Product,
+    params: {
+      referenceDate: Date;
+      deliveryProviderType: DeliveryProviderType;
+    },
+    requestContext: Context,
+  ): Promise<
+    Array<{
+      _id: string;
+      deliveryProvider?: DeliveryProvider;
+      warehousingProvider?: WarehousingProvider;
+      quantity?: number;
+    }>
+  > {
     const { modules } = requestContext;
     const { referenceDate, deliveryProviderType } = params;
 
@@ -96,13 +125,15 @@ export const SimpleProduct: SimpleProductHelperTypes = {
     }, Promise.resolve([]));
   },
 
-  baseUnit: (obj) => {
-    return obj.warehousing && obj.warehousing.baseUnit;
+  baseUnit({ warehousing }): string {
+    return warehousing?.baseUnit;
   },
-  sku: (obj) => {
-    return obj.warehousing && obj.warehousing.sku;
+
+  sku({ warehousing }): string {
+    return warehousing?.sku;
   },
-  dimensions: ({ supply }) => {
+
+  dimensions({ supply }): ProductSupply {
     if (!supply) return null;
     const { weightInGram, heightInMillimeters, lengthInMillimeters, widthInMillimeters } = supply;
     return {

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

@@ -1,28 +1,49 @@
-import { TokenizedProductHelperTypes } from '@unchainedshop/types/products.js';
-import { WarehousingContext } from '@unchainedshop/types/warehousing.js';
+import {
+  Product,
+  ProductContractConfiguration,
+  ProductContractStandard,
+} from '@unchainedshop/types/products.js';
+import { WarehousingContext, WarehousingProvider } from '@unchainedshop/types/warehousing.js';
+import { Context } from '@unchainedshop/types/api.js';
+import { DeliveryProvider } from '@unchainedshop/types/delivery.js';
 import { PlanProduct } from './product-plan-types.js';
+import { checkAction } from '../../../acl.js';
+import { actions } from '../../../roles/index.js';
 
-export const TokenizedProduct: TokenizedProductHelperTypes = {
+export const TokenizedProduct = {
   ...PlanProduct,
 
-  contractAddress(product) {
-    return product.tokenization?.contractAddress;
+  contractAddress({ tokenization }: Product): string {
+    return tokenization?.contractAddress;
   },
 
-  contractConfiguration(product) {
-    if (!product.tokenization) return null;
+  contractConfiguration({ tokenization }: Product): ProductContractConfiguration {
+    if (!tokenization) return null;
     return {
-      supply: product.tokenization.supply,
-      tokenId: product.tokenization.tokenId,
-      ercMetadataProperties: product.tokenization.ercMetadataProperties,
+      supply: tokenization.supply,
+      tokenId: tokenization.tokenId,
+      ercMetadataProperties: tokenization.ercMetadataProperties,
     };
   },
 
-  contractStandard(product) {
-    return product.tokenization?.contractStandard;
+  contractStandard({ tokenization }: Product): ProductContractStandard {
+    return tokenization?.contractStandard;
   },
 
-  simulatedStocks: async (obj, params, requestContext) => {
+  async simulatedStocks(
+    obj: Product,
+    params: {
+      referenceDate: Date;
+    },
+    requestContext: Context,
+  ): Promise<
+    Array<{
+      _id: string;
+      deliveryProvider?: DeliveryProvider;
+      warehousingProvider?: WarehousingProvider;
+      quantity?: number;
+    }>
+  > {
     const { modules } = requestContext;
     const { referenceDate } = params;
 
@@ -64,6 +85,15 @@ export const TokenizedProduct: TokenizedProductHelperTypes = {
       return result.concat(result, mappedWarehousingProviders);
     }, Promise.resolve([]));
   },
+
+  async tokens(product: Product, params: never, requestContext: Context) {
+    await checkAction(requestContext, actions.viewTokens, [undefined, params]);
+
+    const tokens = await requestContext.modules.warehousing.findTokens({
+      productId: product._id,
+    });
+    return tokens;
+  },
 };
 
 delete TokenizedProduct.salesUnit;

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

@@ -1,40 +1,91 @@
-import { ProductHelperTypes } from '@unchainedshop/types/products.js';
-import { ProductTypes } from '@unchainedshop/core-products';
+import { ProductText, Product as ProductType } from '@unchainedshop/types/products.js';
+import { ProductStatus, ProductTypes } from '@unchainedshop/core-products';
 import { objectInvert } from '@unchainedshop/utils';
+import { Context, SortOption } from '@unchainedshop/types/api.js';
+import { AssortmentPathLink } from '@unchainedshop/types/assortments.js';
+import { ProductMedia } from '@unchainedshop/types/products.media.js';
+import { ProductReview } from '@unchainedshop/types/products.reviews.js';
 
-export const Product: ProductHelperTypes = {
-  __resolveType: (obj) => {
+export const Product = {
+  __resolveType: (product: ProductType): string => {
     const invertedProductTypes = objectInvert(ProductTypes);
-    return invertedProductTypes[obj.type];
+    return invertedProductTypes[product.type];
   },
 
-  assortmentPaths: async (obj, _, { modules }) => {
+  async assortmentPaths(
+    product: ProductType,
+    params: {
+      forceLocale?: string;
+    },
+    { modules }: Context,
+  ): Promise<
+    Array<{
+      links: Array<AssortmentPathLink>;
+    }>
+  > {
     return modules.assortments.breadcrumbs({
-      productId: obj._id,
+      productId: product._id,
     });
   },
 
-  media: async (obj, params, { modules }) => {
+  async media(
+    product: ProductType,
+    params: {
+      limit: number;
+      offset: number;
+      tags?: Array<string>;
+    },
+    { modules }: Context,
+  ): Promise<Array<ProductMedia>> {
     return modules.products.media.findProductMedias({
-      productId: obj._id,
+      productId: product._id,
       ...params,
     });
   },
 
-  reviews: async (obj, { limit = 10, offset = 0, sort, queryString }, { modules }) => {
+  async reviews(
+    product: ProductType,
+    {
+      limit = 10,
+      offset = 0,
+      sort,
+      queryString,
+    }: {
+      queryString?: string;
+      limit?: number;
+      offset?: number;
+      sort?: Array<SortOption>;
+    },
+    { modules }: Context,
+  ): Promise<Array<ProductReview>> {
     return modules.products.reviews.findProductReviews({
-      productId: obj._id,
+      productId: product._id,
       limit,
       offset,
       sort,
       queryString,
     });
   },
-  reviewsCount: async (obj, params, { modules }) => {
-    return modules.products.reviews.count({ ...params, productId: obj._id });
+  async reviewsCount(
+    product: ProductType,
+    params: {
+      queryString?: string;
+    },
+    { modules }: Context,
+  ): Promise<number> {
+    return modules.products.reviews.count({ ...params, productId: product._id });
   },
 
-  siblings: async (product, params, { modules }) => {
+  async siblings(
+    product: ProductType,
+    params: {
+      assortmentId?: string;
+      limit: number;
+      offset: number;
+      includeInactive: boolean;
+    },
+    { modules }: Context,
+  ): Promise<Array<typeof product>> {
     const { assortmentId, limit, offset, includeInactive = false } = params;
 
     const productId = product._id;
@@ -57,14 +108,22 @@ export const Product: ProductHelperTypes = {
     });
   },
 
-  status(obj, _, { modules }) {
-    return modules.products.normalizedStatus(obj);
+  status(product: ProductType, _, { modules }: Context): ProductStatus {
+    return modules.products.normalizedStatus(product);
   },
 
-  async texts(obj, { forceLocale }, requestContext) {
+  async texts(
+    product: ProductType,
+    {
+      forceLocale,
+    }: {
+      forceLocale?: string;
+    },
+    requestContext: Context,
+  ): Promise<ProductText> {
     const { localeContext, loaders } = requestContext;
     return loaders.productTextLoader.load({
-      productId: obj._id,
+      productId: product._id,
       locale: forceLocale || localeContext.normalized,
     });
   },

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

@@ -1,36 +1,23 @@
 import { Context } from '@unchainedshop/types/api.js';
-import { Product } from '@unchainedshop/types/products.js';
-import { User } from '@unchainedshop/types/user.js';
 import { TokenStatus, TokenSurrogate } from '@unchainedshop/types/warehousing.js';
 import { WorkStatus } from '@unchainedshop/types/worker.js';
 import localePkg from 'locale';
+import { checkAction } from '../../acl.js';
+import { actions } from '../../roles/index.js';
 
 const { Locale } = localePkg;
 
-type HelperType<T> = (root: TokenSurrogate, params: never, context: Context) => Promise<T>;
-
-export interface TokenHelperTypes {
-  product: HelperType<Product>;
-  status: HelperType<TokenStatus>;
-  ercMetadata: (
-    root: TokenSurrogate,
-    params: { forceLocale?: string },
-    context: Context,
-  ) => Promise<any>;
-  user: HelperType<User>;
-}
-
-export const Token: TokenHelperTypes = {
-  product: async (token, _params, { modules }) => {
+export const Token = {
+  product: async (token: TokenSurrogate, params: never, { modules }: Context) => {
     return modules.products.findProduct({ productId: token.productId });
   },
 
-  user: async (token, _params, { modules }) => {
+  user: async (token: TokenSurrogate, params: never, { modules }: Context) => {
     if (!token.userId) return null;
     return modules.users.findUserById(token.userId);
   },
 
-  status: async (token, _params, { modules }) => {
+  status: async (token: TokenSurrogate, params: never, { modules }: Context) => {
     if (token.walletAddress && !token.userId) {
       return TokenStatus.DECENTRALIZED;
     }
@@ -42,7 +29,11 @@ export const Token: TokenHelperTypes = {
     return TokenStatus.CENTRALIZED;
   },
 
-  ercMetadata: async (token, { forceLocale }, context) => {
+  ercMetadata: async (
+    token: TokenSurrogate,
+    { forceLocale }: { forceLocale: string },
+    context: Context,
+  ) => {
     const { modules } = context;
     const product = await modules.products.findProduct({ productId: token.productId });
     const ercMetadata = await modules.warehousing.tokenMetadata(
@@ -58,4 +49,28 @@ export const Token: TokenHelperTypes = {
 
     return ercMetadata;
   },
+
+  isInvalidateable: async (token: TokenSurrogate, _params: never, context: Context) => {
+    const { modules } = context;
+    const product = await modules.products.findProduct({ productId: token.productId });
+    const isInvalidateable = await modules.warehousing.isInvalidateable(
+      token.chainTokenId,
+      {
+        token,
+        product,
+        referenceDate: new Date(),
+      },
+      context,
+    );
+
+    return isInvalidateable;
+  },
+
+  accessKey: async (token: TokenSurrogate, params: never, requestContext: Context) => {
+    const { modules } = requestContext;
+    await checkAction(requestContext, actions.updateToken, [undefined, { tokenId: token._id }]);
+    // This generates a hash that is stable until ownership is changed and allows accessing token
+    // data and operations
+    return modules.warehousing.buildAccessKeyForToken(token._id);
+  },
 };