@unchainedshop/api 3.0.0-alpha7 → 3.0.0-rc1

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

@@ -1,5 +1,5 @@
 import { log } from '@unchainedshop/logger';
-import { Context } from '../../../types.js';
+import { Context } from '../../../context.js';
 import { InvalidIdError } from '../../../errors.js';
 
 export default async function token(

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

@@ -1,5 +1,5 @@
 import { log } from '@unchainedshop/logger';
-import { Context } from '../../../types.js';
+import { Context } from '../../../context.js';
 
 export default async function tokens(
   root: never,

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

@@ -1,13 +1,20 @@
-import { Context } from '../../../types.js';
+import { WarehousingDirector } from '@unchainedshop/core';
+import { Context } from '../../../context.js';
 import { WarehousingProviderType } from '@unchainedshop/core-warehousing';
 import { log } from '@unchainedshop/logger';
 
 export default async function warehousingInterfaces(
   root: never,
-  params: { type: WarehousingProviderType },
-  { modules, userId }: Context,
+  { type }: { type: WarehousingProviderType },
+  { userId }: Context,
 ) {
-  log(`query warehousingInterfaces ${params.type}`, { userId });
+  log(`query warehousingInterfaces ${type}`, { userId });
 
-  return modules.warehousing.findInterfaces(params);
+  return WarehousingDirector.getAdapters({
+    adapterFilter: (Adapter) => Adapter.typeSupported(type),
+  }).map((Adapter) => ({
+    _id: Adapter.key,
+    label: Adapter.label,
+    version: Adapter.version,
+  }));
 }

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

@@ -1,5 +1,5 @@
 import { log } from '@unchainedshop/logger';
-import { Context } from '../../../types.js';
+import { Context } from '../../../context.js';
 import { InvalidIdError } from '../../../errors.js';
 
 export default async function warehousingProvider(

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

@@ -1,10 +1,12 @@
-import { Context } from '../../../types.js';
-import { WarehousingProviderQuery } from '@unchainedshop/core-warehousing';
+import { WarehousingProviderType } from '@unchainedshop/core-warehousing';
+import { Context } from '../../../context.js';
 import { log } from '@unchainedshop/logger';
 
 export default async function warehousingProviders(
   root: never,
-  params: WarehousingProviderQuery,
+  params: {
+    type?: WarehousingProviderType;
+  },
   { modules, userId }: Context,
 ) {
   log(`query warehousingProviders ${params.type}`, { userId });

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

@@ -1,10 +1,12 @@
-import { Context } from '../../../types.js';
-import { WarehousingProviderQuery } from '@unchainedshop/core-warehousing';
+import { Context } from '../../../context.js';
+import { WarehousingProviderType } from '@unchainedshop/core-warehousing';
 import { log } from '@unchainedshop/logger';
 
 export default async function warehousingProvidersCount(
   root: never,
-  params: WarehousingProviderQuery,
+  params: {
+    type?: WarehousingProviderType;
+  },
   { modules, userId }: Context,
 ) {
   log(`query warehousingProvidersCount ${params.type}`, { userId });

package/src/resolvers/queries/worker/activeWorkTypes.ts

@@ -1,8 +1,13 @@
-import { Context } from '../../../types.js';
+import { WorkerDirector } from '@unchainedshop/core';
+import { Context } from '../../../context.js';
 import { log } from '@unchainedshop/logger';
 
 export default async function activeWorkTypes(root: never, _: any, { modules, userId }: Context) {
   log(`query activeWorkTypes  `, { userId });
 
-  return modules.worker.activeWorkTypes();
+  const typeList = await modules.worker.activeWorkTypes();
+  const pluginTypes = WorkerDirector.getActivePluginTypes();
+  return typeList.filter((type) => {
+    return pluginTypes.includes(type);
+  });
 }

package/src/resolvers/queries/worker/work.ts

@@ -1,5 +1,5 @@
 import { log } from '@unchainedshop/logger';
-import { Context } from '../../../types.js';
+import { Context } from '../../../context.js';
 import { InvalidIdError } from '../../../errors.js';
 
 export default async function work(

package/src/resolvers/queries/worker/workQueue.ts

@@ -1,7 +1,7 @@
 import { log } from '@unchainedshop/logger';
 import { SortOption } from '@unchainedshop/utils';
 import { WorkStatus } from '@unchainedshop/core-worker';
-import { Context } from '../../../types.js';
+import { Context } from '../../../context.js';
 
 export default async function workQueue(
   root: never,

package/src/resolvers/queries/worker/workQueueCount.ts

@@ -1,6 +1,6 @@
 import { log } from '@unchainedshop/logger';
-import { Context } from '../../../types.js';
-import { WorkQueueQuery } from '@unchainedshop/core-worker/module/configureWorkerModule.js';
+import { Context } from '../../../context.js';
+import { WorkQueueQuery } from '@unchainedshop/core-worker';
 
 export default async function workQueueCount(
   root: never,

package/src/resolvers/queries/worker/workStatistics.ts

@@ -1,13 +1,15 @@
 import { log } from '@unchainedshop/logger';
-import { Context } from '../../../types.js';
+import { Context } from '../../../context.js';
+import { DateFilterInput } from '@unchainedshop/utils';
 
 export default async function workStatistics(
   root: never,
-  params: { types?: string[]; from?: Date; to?: Date },
+  params: { types?: string[]; dateRange?: DateFilterInput },
   { modules, userId }: Context,
 ) {
-  log(`query workStatistics ${params.from || ''} ${params.to || ''}`, {
+  log(`query workStatistics ${(params?.types || []).join(', ')}`, {
     userId,
+    ...(params.dateRange || {}),
   });
 
   return modules.worker.getReport(params);

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

@@ -1,6 +1,6 @@
 import { Assortment, AssortmentFilter as AssortmentFilterType } from '@unchainedshop/core-assortments';
 import { Filter } from '@unchainedshop/core-filters';
-import { Context } from '../../../types.js';
+import { Context } from '../../../context.js';
 
 type HelperType<T> = (assortmentFilter: AssortmentFilterType, _: never, context: Context) => T;
 

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

@@ -1,4 +1,4 @@
-import { Context } from '../../../types.js';
+import { Context } from '../../../context.js';
 import { Assortment, AssortmentLink as AssortmentLinkType } from '@unchainedshop/core-assortments';
 
 type HelperType<T> = (assortmentLink: AssortmentLinkType, _: never, context: Context) => T;

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

@@ -1,4 +1,4 @@
-import { Context } from '../../../types.js';
+import { Context } from '../../../context.js';
 import { AssortmentMediaType, AssortmentMediaText } from '@unchainedshop/core-assortments';
 import { File } from '@unchainedshop/core-files';
 

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

@@ -1,4 +1,4 @@
-import { Context } from '../../../types.js';
+import { Context } from '../../../context.js';
 import {
   AssortmentPathLink as AssortmentPathLinkType,
   AssortmentLink as AssortmentLinkType,

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

@@ -1,4 +1,4 @@
-import { Context } from '../../../types.js';
+import { Context } from '../../../context.js';
 import { Assortment, AssortmentProduct as AssortmentProductType } from '@unchainedshop/core-assortments';
 import { Product } from '@unchainedshop/core-products';
 

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

@@ -1,66 +1,30 @@
-import { Context } from '../../../types.js';
-import {
-  Assortment as AssortmentType,
-  AssortmentFilter,
-  AssortmentLink,
-  AssortmentPathLink,
-  AssortmentProduct,
-  AssortmentText,
-} from '@unchainedshop/core-assortments';
-import { AssortmentMediaType } from '@unchainedshop/core-assortments';
-import { SearchFilterQuery, SearchProducts } from '@unchainedshop/core-filters';
+import { Context } from '../../../context.js';
+import { Assortment } from '@unchainedshop/core-assortments';
+import { SearchFilterQuery } from '@unchainedshop/core-filters';
 
-type HelperType<P, T> = (assortment: AssortmentType, params: P, context: Context) => T;
-
-export interface AssortmentHelperTypes {
-  assortmentPaths: HelperType<never, Promise<Array<{ links: Array<AssortmentPathLink> }>>>;
-
-  children: HelperType<{ includeInactive: boolean }, Promise<Array<AssortmentType>>>;
-  childrenCount: HelperType<{ includeInactive: boolean }, Promise<number>>;
-
-  filterAssignments: HelperType<never, Promise<Array<AssortmentFilter>>>;
-  linkedAssortments: HelperType<never, Promise<Array<AssortmentLink>>>;
-
-  media: HelperType<
-    {
-      limit: number;
-      offset: number;
-      tags?: Array<string>;
-    },
-    Promise<Array<AssortmentMediaType>>
-  >;
-
-  productAssignments: HelperType<never, Promise<Array<AssortmentProduct>>>;
-
-  searchProducts: HelperType<
-    {
-      queryString?: string;
-      filterQuery?: SearchFilterQuery;
-      includeInactive: boolean;
-      ignoreChildAssortments: boolean;
-      orderBy?: string;
-    },
-    Promise<SearchProducts>
-  >;
-
-  texts: HelperType<{ forceLocale?: string }, Promise<AssortmentText>>;
-}
-
-export const Assortment: AssortmentHelperTypes = {
-  assortmentPaths: (obj, _, { modules }) => {
+export const AssortmentTypes = {
+  assortmentPaths: (obj: Assortment, _, { modules }: Context) => {
     return modules.assortments.breadcrumbs({
       assortmentId: obj._id,
     });
   },
 
-  children: async (obj, { includeInactive }, { modules }) => {
+  children: async (
+    obj: Assortment,
+    { includeInactive }: { includeInactive: boolean },
+    { modules }: Context,
+  ) => {
     return modules.assortments.children({
       assortmentId: obj._id,
       includeInactive,
     });
   },
 
-  childrenCount: async (assortment, { includeInactive = false }, { modules, loaders }) => {
+  childrenCount: async (
+    assortment: Assortment,
+    { includeInactive = false }: { includeInactive: boolean },
+    { modules, loaders }: Context,
+  ) => {
     const assortmentChildLinks = await loaders.assortmentLinksLoader.load({
       parentAssortmentId: assortment._id,
     });
@@ -74,7 +38,7 @@ export const Assortment: AssortmentHelperTypes = {
     });
   },
 
-  filterAssignments: async (obj, _, { modules }) => {
+  filterAssignments: async (obj: Assortment, _, { modules }: Context) => {
     // TODO: Loader & move default sort to module
     return modules.assortments.filters.findFilters(
       {
@@ -86,21 +50,34 @@ export const Assortment: AssortmentHelperTypes = {
     );
   },
 
-  async linkedAssortments(assortment, _, { loaders }) {
+  async linkedAssortments(assortment: Assortment, _, { loaders }: Context) {
     return loaders.assortmentLinksLoader.load({
       assortmentId: assortment._id,
     });
   },
 
-  // TODO: Use a loader!
-  async media(obj, params, { modules }) {
-    return modules.assortments.media.findAssortmentMedias({
-      assortmentId: obj._id,
-      ...params,
-    });
+  async media(
+    obj: Assortment,
+    params: {
+      limit: number;
+      offset: number;
+      tags?: Array<string>;
+    },
+    { modules, loaders }: Context,
+  ) {
+    if (params.offset || params.tags) {
+      return modules.assortments.media.findAssortmentMedias({
+        assortmentId: obj._id,
+        ...params,
+      });
+    }
+    return (await loaders.assortmentMediasLoader.load({ assortmentId: obj._id })).slice(
+      params.offset,
+      params.offset + params.limit,
+    );
   },
 
-  async productAssignments(obj, _, { modules }) {
+  async productAssignments(obj: Assortment, _, { modules }: Context) {
     // TODO: Loader & move default sort to core module
     return modules.assortments.products.findProducts(
       {
@@ -112,7 +89,7 @@ export const Assortment: AssortmentHelperTypes = {
     );
   },
 
-  async texts(obj, { forceLocale }, requestContext) {
+  async texts(obj: Assortment, { forceLocale }: { forceLocale?: string }, requestContext: Context) {
     const { localeContext, loaders } = requestContext;
     return loaders.assortmentTextLoader.load({
       assortmentId: obj._id,
@@ -120,19 +97,26 @@ export const Assortment: AssortmentHelperTypes = {
     });
   },
 
-  searchProducts: async (obj, query, context) => {
-    const productIds = await context.modules.assortments.findProductIds({
+  searchProducts: async (
+    obj: Assortment,
+    query: {
+      queryString?: string;
+      filterQuery?: SearchFilterQuery;
+      includeInactive: boolean;
+      ignoreChildAssortments: boolean;
+      orderBy?: string;
+    },
+    requestContext: Context,
+  ) => {
+    const { modules, services } = requestContext;
+    const productIds = await modules.assortments.findProductIds({
       assortmentId: obj._id,
       ignoreChildAssortments: query.ignoreChildAssortments,
     });
 
-    const filterIds = await context.modules.assortments.filters.findFilterIds({
+    const filterIds = await modules.assortments.filters.findFilterIds({
       assortmentId: obj._id,
     });
-    return context.modules.filters.search.searchProducts(
-      { ...query, productIds, filterIds },
-      {},
-      context,
-    );
+    return services.filters.searchProducts({ ...query, productIds, filterIds }, {});
   },
 };

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

@@ -1,8 +1,8 @@
-import type { Bookmark as BookmarkType } from '@unchainedshop/core-bookmarks';
-import type { Product } from '@unchainedshop/core-products';
-import type { User } from '@unchainedshop/core-users';
+import { Bookmark as BookmarkType } from '@unchainedshop/core-bookmarks';
+import { Product } from '@unchainedshop/core-products';
+import { User } from '@unchainedshop/core-users';
 
-import { Context } from '@unchainedshop/api';
+import { Context } from '../../context.js';
 
 export type HelperType<T> = (bookmark: BookmarkType, _: never, context: Context) => T;
 

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

@@ -1,4 +1,4 @@
-import { Context } from '@unchainedshop/api';
+import { Context } from '../../context.js';
 import { Country as CountryType } from '@unchainedshop/core-countries';
 import { Currency } from '@unchainedshop/core-currencies';
 

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

@@ -1,7 +1,7 @@
-import crypto from 'crypto';
-import { Context } from '@unchainedshop/api';
-import { DeliveryError, DeliveryProvider as DeliveryProviderType } from '@unchainedshop/core-delivery';
-import { DeliveryPricingDirector } from '@unchainedshop/core-delivery';
+import { Context } from '../../context.js';
+import { DeliveryProvider as DeliveryProviderType } from '@unchainedshop/core-delivery';
+import { DeliveryDirector, DeliveryError, DeliveryPricingDirector } from '@unchainedshop/core';
+import { sha256 } from '@unchainedshop/utils';
 
 export type HelperType<P, T> = (provider: DeliveryProviderType, params: P, context: Context) => T;
 
@@ -35,20 +35,24 @@ export interface DeliveryProviderHelperTypes {
 }
 
 export const DeliveryProvider: DeliveryProviderHelperTypes = {
-  interface(obj, _, { modules }) {
-    const Interface = modules.delivery.findInterface(obj);
-    if (!Interface) return null;
-    return Interface;
+  interface(deliveryProvider) {
+    const Adapter = DeliveryDirector.getAdapter(deliveryProvider.adapterKey);
+    if (!Adapter) return null;
+    return {
+      _id: Adapter.key,
+      label: Adapter.label,
+      version: Adapter.version,
+    };
   },
 
   async isActive(deliveryProvider, _, requestContext) {
-    const { modules } = requestContext;
-    return modules.delivery.isActive(deliveryProvider, requestContext);
+    const director = await DeliveryDirector.actions(deliveryProvider, {}, requestContext);
+    return Boolean(director.isActive());
   },
 
   async configurationError(deliveryProvider, _, requestContext) {
-    const { modules } = requestContext;
-    return modules.delivery.configurationError(deliveryProvider, requestContext);
+    const director = await DeliveryDirector.actions(deliveryProvider, {}, requestContext);
+    return director.configurationError();
   },
 
   async simulatedPrice(
@@ -58,24 +62,21 @@ export const DeliveryProvider: DeliveryProviderHelperTypes = {
   ) {
     const { modules, countryContext: country, user } = requestContext;
     const order = await modules.orders.findOrder({ orderId });
-    const currency = currencyCode || requestContext.currencyContext;
+    const currency = currencyCode || order?.currency || requestContext.currencyContext;
+    const pricingContext = {
+      country,
+      currency,
+      provider: deliveryProvider,
+      order,
+      providerContext,
+      user,
+    };
 
-    const pricingDirector = await DeliveryPricingDirector.actions(
-      {
-        country,
-        currency,
-        provider: deliveryProvider,
-        order,
-        providerContext,
-        user,
-      },
-      requestContext,
-    );
+    const calculated = await DeliveryPricingDirector.rebuildCalculation(pricingContext, requestContext);
 
-    const calculated = await pricingDirector.calculate();
     if (!calculated || !calculated.length) return null;
 
-    const pricing = pricingDirector.calculationSheet();
+    const pricing = DeliveryPricingDirector.calculationSheet(pricingContext, calculated);
 
     const orderPrice = pricing.total({ useNetPrice }) as {
       amount: number;
@@ -83,10 +84,7 @@ export const DeliveryProvider: DeliveryProviderHelperTypes = {
     };
 
     return {
-      _id: crypto
-        .createHash('sha256')
-        .update([deliveryProvider._id, country, useNetPrice, order ? order._id : ''].join(''))
-        .digest('hex'),
+      _id: await sha256([deliveryProvider._id, country, useNetPrice, order ? order._id : ''].join('')),
       amount: orderPrice.amount,
       currencyCode: orderPrice.currency,
       countryCode: country,

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

@@ -1,10 +1,10 @@
-import crypto from 'crypto';
 import { DeliveryProvider } from '@unchainedshop/core-delivery';
 import { Product } from '@unchainedshop/core-products';
 import { WarehousingProvider } from '@unchainedshop/core-warehousing';
+import { sha256 } from '@unchainedshop/utils';
 
 export const Dispatch = {
-  _id: (params: {
+  _id: async (params: {
     product: Product;
     deliveryProvider: DeliveryProvider;
     warehousingProvider: WarehousingProvider;
@@ -13,18 +13,15 @@ export const Dispatch = {
     country: string;
     userId?: string;
   }) =>
-    crypto
-      .createHash('sha256')
-      .update(
-        [
-          params.product._id,
-          params.deliveryProvider._id,
-          params.warehousingProvider._id,
-          params.referenceDate,
-          params.quantity,
-          params.country,
-          params.userId || 'ANONYMOUS',
-        ].join(''),
-      )
-      .digest('hex'),
+    await sha256(
+      [
+        params.product._id,
+        params.deliveryProvider._id,
+        params.warehousingProvider._id,
+        params.referenceDate,
+        params.quantity,
+        params.country,
+        params.userId || 'ANONYMOUS',
+      ].join(''),
+    ),
 };

package/src/resolvers/type/enrollment/enrollment-delivery-types.ts

@@ -1,4 +1,4 @@
-import { Context } from '@unchainedshop/api';
+import { Context } from '../../../context.js';
 import { DeliveryProvider } from '@unchainedshop/core-delivery';
 import { Enrollment } from '@unchainedshop/core-enrollments';
 

package/src/resolvers/type/enrollment/enrollment-payment-types.ts

@@ -1,4 +1,4 @@
-import { Context } from '@unchainedshop/api';
+import { Context } from '../../../context.js';
 import { PaymentProvider } from '@unchainedshop/core-payment';
 import { Enrollment } from '@unchainedshop/core-enrollments';
 

package/src/resolvers/type/enrollment/enrollment-period-types.ts

@@ -1,4 +1,4 @@
-import { Context } from '@unchainedshop/api';
+import { Context } from '../../../context.js';
 import { EnrollmentPeriod as EnrollmentPeriodType } from '@unchainedshop/core-enrollments';
 import { Order } from '@unchainedshop/core-orders';
 

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

@@ -1,4 +1,4 @@
-import { Context } from '@unchainedshop/api';
+import { Context } from '../../../context.js';
 import { EnrollmentPlan as EnrollmentPlanType } from '@unchainedshop/core-enrollments';
 import { Product } from '@unchainedshop/core-products';
 

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

@@ -1,4 +1,4 @@
-import { Context } from '@unchainedshop/api';
+import { Context } from '../../../context.js';
 import { Country } from '@unchainedshop/core-countries';
 import { Currency } from '@unchainedshop/core-currencies';
 import { Enrollment as EnrollmentType, EnrollmentPlan } from '@unchainedshop/core-enrollments';

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

@@ -1,5 +1,5 @@
-import { Context } from '@unchainedshop/api';
-import type { Event as EventType } from '@unchainedshop/core-events';
+import { Context } from '../../context.js';
+import { Event as EventType } from '@unchainedshop/core-events';
 
 export type HelperType<P, T> = (work: EventType, params: P, context: Context) => T;
 

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

@@ -1,4 +1,4 @@
-import { Context } from '@unchainedshop/api';
+import { Context } from '../../../context.js';
 import { FilterOption as FilterOptionType, FilterText } from '@unchainedshop/core-filters';
 
 type HelperType<P, T> = (filterOption: FilterOptionType, params: P, context: Context) => T;

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

@@ -1,4 +1,4 @@
-import { Context } from '@unchainedshop/api';
+import { Context } from '../../../context.js';
 import { Filter as FilterType, FilterOption, FilterText } from '@unchainedshop/core-filters';
 
 type HelperType<P, T> = (filter: FilterType, params: P, context: Context) => T;

package/src/resolvers/type/filter/loaded-filter-option-types.ts

@@ -1 +1,18 @@
-export const LoadedFilterOption = {};
+import { FilterDirector } from '@unchainedshop/core';
+import { Context } from '../../../context.js';
+
+export const LoadedFilterOption = {
+  filteredProductsCount: async ({ filteredProductIdSet, searchQuery }, _: never, context: Context) => {
+    if (!filteredProductIdSet?.size) {
+      return 0;
+    }
+    const filterActions = await FilterDirector.actions({ searchQuery }, context);
+    return filterActions.aggregateProductIds({
+      productIds: Array.from(filteredProductIdSet),
+    }).length;
+  },
+
+  definition: ({ filter, value }) => {
+    return { filterOption: value, ...filter };
+  },
+};