@unchainedshop/api 3.1.15 → 4.0.0-rc.11

package/src/resolvers/queries/orders/orders.ts

@@ -2,17 +2,58 @@ import { log } from '@unchainedshop/logger';
 import { SortOption } from '@unchainedshop/utils';
 import { OrderQuery } from '@unchainedshop/core-orders';
 import { Context } from '../../../context.js';
+import { PaymentProviderType } from '@unchainedshop/core-payment';
+import { DeliveryProviderType } from '@unchainedshop/core-delivery';
 
 export default async function orders(
   root: never,
-  params: OrderQuery & { limit?: number; offset?: number; sort?: Array<SortOption> },
+  params: OrderQuery & { limit?: number; offset?: number; sort?: SortOption[] },
   { modules, userId }: Context,
 ) {
-  const { includeCarts, limit, offset, queryString } = params;
+  const { limit, offset, paymentProviderTypes, deliveryProviderTypes, ...restParams } = params;
+  log(`query orders: ${limit} ${offset}  ${restParams?.queryString || ''}`, { userId });
 
-  log(`query orders: ${limit} ${offset} ${includeCarts} ${queryString}`, {
-    userId,
-  });
+  const promises: Promise<any>[] = [];
+
+  let paymentProviderIds: string[] | undefined;
+  let deliveryProviderIds: string[] | undefined;
+
+  if (paymentProviderTypes?.length) {
+    promises.push(
+      modules.payment.paymentProviders
+        .findProviders({ type: { $in: paymentProviderTypes as PaymentProviderType[] } })
+        .then((providers) => (paymentProviderIds = providers.map((p) => p._id))),
+    );
+  }
 
-  return modules.orders.findOrders(params);
+  if (deliveryProviderTypes?.length) {
+    promises.push(
+      modules.delivery
+        .findProviders({ type: { $in: deliveryProviderTypes as DeliveryProviderType[] } })
+        .then((providers) => (deliveryProviderIds = providers.map((p) => p._id))),
+    );
+  }
+
+  await Promise.all(promises);
+  const [orderPayments, orderDeliveries] = await Promise.all([
+    paymentProviderIds
+      ? modules.orders.payments.findOrderPaymentsByProviderIds({ paymentProviderIds })
+      : [],
+    deliveryProviderIds
+      ? modules.orders.deliveries.findDeliveryByProvidersId({ deliveryProviderIds })
+      : [],
+  ]);
+  if (
+    (paymentProviderTypes?.length && !orderPayments.length) ||
+    (deliveryProviderTypes?.length && !orderDeliveries.length)
+  )
+    return [];
+  const paymentIds = orderPayments.map((p) => p._id);
+  const deliveryIds = orderDeliveries.map((d) => d._id);
+
+  return modules.orders.findOrders({
+    ...restParams,
+    paymentIds,
+    deliveryIds,
+  });
 }

package/src/resolvers/queries/orders/ordersCount.ts

@@ -1,13 +1,54 @@
 import { log } from '@unchainedshop/logger';
 import { OrderQuery } from '@unchainedshop/core-orders';
 import { Context } from '../../../context.js';
+import { PaymentProviderType } from '@unchainedshop/core-payment';
+import { DeliveryProviderType } from '@unchainedshop/core-delivery';
 
 export default async function ordersCount(
   root: never,
   params: OrderQuery,
   { modules, userId }: Context,
 ) {
+  const { paymentProviderTypes, deliveryProviderTypes, ...restParams } = params;
   log(`query ordersCount: ${params.includeCarts ? 'includeCart' : ''}`, { userId });
 
-  return modules.orders.count(params);
+  const promises: Promise<any>[] = [];
+
+  let paymentProviderIds: string[] | undefined;
+  let deliveryProviderIds: string[] | undefined;
+
+  if (paymentProviderTypes?.length) {
+    promises.push(
+      modules.payment.paymentProviders
+        .findProviders({ type: { $in: paymentProviderTypes as PaymentProviderType[] } })
+        .then((providers) => (paymentProviderIds = providers.map((p) => p._id))),
+    );
+  }
+
+  if (deliveryProviderTypes?.length) {
+    promises.push(
+      modules.delivery
+        .findProviders({ type: { $in: deliveryProviderTypes as DeliveryProviderType[] } })
+        .then((providers) => (deliveryProviderIds = providers.map((p) => p._id))),
+    );
+  }
+
+  await Promise.all(promises);
+  const [orderPayments, orderDeliveries] = await Promise.all([
+    paymentProviderIds
+      ? modules.orders.payments.findOrderPaymentsByProviderIds({ paymentProviderIds })
+      : [],
+    deliveryProviderIds
+      ? modules.orders.deliveries.findDeliveryByProvidersId({ deliveryProviderIds })
+      : [],
+  ]);
+  if (
+    (paymentProviderTypes?.length && !orderPayments.length) ||
+    (deliveryProviderTypes && !orderDeliveries.length)
+  )
+    return 0;
+  const paymentIds = orderPayments.map((p) => p._id);
+  const deliveryIds = orderDeliveries.map((d) => d._id);
+
+  return modules.orders.count({ ...restParams, paymentIds, deliveryIds });
 }

package/src/resolvers/queries/products/productReviews.ts

@@ -7,7 +7,7 @@ export default async function productReviews(
   params: {
     limit: number;
     offset: number;
-    sort: Array<SortOption>;
+    sort: SortOption[];
     queryString?: string;
   },
   { modules, userId }: Context,

package/src/resolvers/queries/products/products.ts

@@ -6,7 +6,7 @@ import { Context } from '../../../context.js';
 export default async function products(
   root: never,
   params: ProductQuery & {
-    sort: Array<SortOption>;
+    sort: SortOption[];
     limit: number;
     offset: number;
   },

package/src/resolvers/queries/quotations/quotations.ts

@@ -5,7 +5,7 @@ import { Context } from '../../../context.js';
 
 export default async function quotations(
   root: never,
-  params: QuotationQuery & { limit?: number; offset?: number; sort?: Array<SortOption> },
+  params: QuotationQuery & { limit?: number; offset?: number; sort?: SortOption[] },
   { modules, userId }: Context,
 ) {
   log(`query quotations: ${params.limit} ${params.offset}`, { userId });

package/src/resolvers/queries/users/impersonator.ts

@@ -9,5 +9,6 @@ export default async function impersonator(
   log(`query impersonator`, { userId });
 
   if (!impersonatorId) return null;
-  return modules.users.findUserById(impersonatorId);
+
+  return modules.users.findUser({ userId: impersonatorId });
 }

package/src/resolvers/queries/users/user.ts

@@ -7,5 +7,6 @@ export default async function user(
   { modules, userId }: Context,
 ) {
   log(`query user ${params.userId}`, { Id: userId });
+
   return modules.users.findUserById(params.userId || userId);
 }

package/src/resolvers/queries/users/users.ts

@@ -8,7 +8,7 @@ export default async function users(
   params: UserQuery & {
     limit?: number;
     offset?: number;
-    sort?: Array<SortOption>;
+    sort?: SortOption[];
     includeGuests?: boolean;
     emailVerified?: boolean;
     lastLogin?: DateFilterInput;

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

@@ -17,13 +17,13 @@ export default async function workQueue(
     limit?: number;
     offset?: number;
     queryString?: string;
-    status?: Array<WorkStatus>;
-    types?: Array<string>;
+    status?: WorkStatus[];
+    types?: string[];
     created?: {
       start: Date;
       end: Date;
     };
-    sort?: Array<SortOption>;
+    sort?: SortOption[];
   },
   { modules, userId }: Context,
 ) {

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

@@ -1,26 +1,16 @@
-import { Assortment, AssortmentFilter as AssortmentFilterType } from '@unchainedshop/core-assortments';
-import { Filter } from '@unchainedshop/core-filters';
+import { AssortmentFilter as AssortmentFilterType } from '@unchainedshop/core-assortments';
 import { Context } from '../../../context.js';
 
-type HelperType<T> = (assortmentFilter: AssortmentFilterType, _: never, context: Context) => T;
-
-export type AssortmentFilterHelperTypes = {
-  assortment: HelperType<Promise<Assortment>>;
-  filter: HelperType<Promise<Filter>>;
-};
-
-export const AssortmentFilter: AssortmentFilterHelperTypes = {
-  assortment: async (obj, _, { loaders }) => {
-    const assortment = await loaders.assortmentLoader.load({
+export const AssortmentFilter = {
+  async assortment(obj: AssortmentFilterType, _, { loaders }: Context) {
+    return loaders.assortmentLoader.load({
       assortmentId: obj.assortmentId,
     });
-    return assortment;
   },
 
-  filter: async (obj, _, { loaders }) => {
-    const filter = await loaders.filterLoader.load({
+  async filter(obj: AssortmentFilterType, _, { loaders }: Context) {
+    return loaders.filterLoader.load({
       filterId: obj.filterId,
     });
-    return filter;
   },
 };

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

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

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

@@ -11,10 +11,10 @@ export interface AssortmentMediaHelperTypes {
 
 export const AssortmentMedia: AssortmentMediaHelperTypes = {
   async texts(obj, { forceLocale }, requestContext) {
-    const { localeContext, loaders } = requestContext;
+    const { locale, loaders } = requestContext;
     return loaders.assortmentMediaTextLoader.load({
       assortmentMediaId: obj._id,
-      locale: forceLocale || localeContext.baseName,
+      locale: forceLocale ? new Intl.Locale(forceLocale) : locale,
     });
   },
 

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

@@ -13,12 +13,12 @@ export const AssortmentPathLink = {
 
   assortmentTexts: async (
     { childAssortmentId }: AssortmentLink,
-    params: { forceLocale?: string },
-    { loaders, localeContext }: Context,
+    { forceLocale }: { forceLocale?: string },
+    { loaders, locale }: Context,
   ) => {
     const text = await loaders.assortmentTextLoader.load({
       assortmentId: childAssortmentId,
-      locale: params.forceLocale || localeContext.baseName,
+      locale: forceLocale ? new Intl.Locale(forceLocale) : locale,
     });
     return text;
   },

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

@@ -4,10 +4,10 @@ import { Product } from '@unchainedshop/core-products';
 
 type HelperType<T> = (assortmentProduct: AssortmentProductType, _: never, context: Context) => T;
 
-export type AssortmentProductHelperTypes = {
+export interface AssortmentProductHelperTypes {
   assortment: HelperType<Promise<Assortment>>;
   product: HelperType<Promise<Product>>;
-};
+}
 
 export const AssortmentProduct: AssortmentProductHelperTypes = {
   assortment: async (obj, _, { loaders }) => {

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

@@ -51,7 +51,7 @@ export const AssortmentTypes = {
   },
 
   async filterAssignments(obj: Assortment, _, { modules }: Context) {
-    // TODO: Loader & move default sort to module
+    // TODO: move default sort to module
     return modules.assortments.filters.findFilters(
       {
         assortmentId: obj._id,
@@ -73,7 +73,7 @@ export const AssortmentTypes = {
     params: {
       limit: number;
       offset: number;
-      tags?: Array<string>;
+      tags?: string[];
     },
     { modules, loaders }: Context,
   ) {
@@ -90,7 +90,7 @@ export const AssortmentTypes = {
   },
 
   async productAssignments(obj: Assortment, _, { modules }: Context) {
-    // TODO: Loader & move default sort to core module
+    // TODO: move default sort to core module
     return modules.assortments.products.findAssortmentProducts(
       {
         assortmentId: obj._id,
@@ -102,10 +102,10 @@ export const AssortmentTypes = {
   },
 
   async texts(obj: Assortment, { forceLocale }: { forceLocale?: string }, requestContext: Context) {
-    const { localeContext, loaders } = requestContext;
+    const { locale, loaders } = requestContext;
     return loaders.assortmentTextLoader.load({
       assortmentId: obj._id,
-      locale: forceLocale || localeContext.baseName,
+      locale: forceLocale ? new Intl.Locale(forceLocale) : locale,
     });
   },
 
@@ -132,7 +132,7 @@ export const AssortmentTypes = {
     return services.filters.searchProducts(
       { ...query, productIds, filterIds },
       {
-        locale: requestContext.localeContext,
+        locale: requestContext.locale,
       },
     );
   },

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

@@ -19,8 +19,7 @@ export const Bookmark: BookmarkHelperTypes = {
     return product;
   },
 
-  user: async (obj, _, { modules }) => {
-    // TODO: use loader
-    return modules.users.findUserById(obj.userId);
+  user: async (obj, _, { loaders }) => {
+    return loaders.userLoader.load({ userId: obj.userId });
   },
 };

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

@@ -7,17 +7,14 @@ export type HelperType<P, T> = (country: CountryType, params: P, context: Contex
 export interface CountryHelperTypes {
   flagEmoji: HelperType<never, string>;
   isBase: HelperType<never, boolean>;
-  name: HelperType<{ forceLocale: string }, string>;
+  name: HelperType<{ forceLocale?: string }, string>;
   defaultCurrency: HelperType<never, Promise<Currency>>;
 }
 
 export const Country: CountryHelperTypes = {
-  defaultCurrency: async (country, _, { modules }) => {
+  defaultCurrency: async (country, _, { loaders }) => {
     if (country.defaultCurrencyCode) {
-      // TODO: use loader
-      return modules.currencies.findCurrency({
-        isoCode: country.defaultCurrencyCode,
-      });
+      return loaders.currencyLoader.load({ isoCode: country.defaultCurrencyCode });
     }
     return null;
   },
@@ -28,7 +25,7 @@ export const Country: CountryHelperTypes = {
   isBase: (country, _, { modules }: Context) => {
     return modules.countries.isBase(country);
   },
-  name: (country, { forceLocale }, { localeContext, modules }) => {
-    return modules.countries.name(country, forceLocale || localeContext.language);
+  name: (country, { forceLocale }, { locale, modules }) => {
+    return modules.countries.name(country, forceLocale ? new Intl.Locale(forceLocale) : locale);
   },
 };

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

@@ -1,39 +1,9 @@
 import { Context } from '../../context.js';
 import { DeliveryProvider as DeliveryProviderType } from '@unchainedshop/core-delivery';
-import { DeliveryDirector, DeliveryError, DeliveryPricingDirector } from '@unchainedshop/core';
+import { DeliveryDirector, DeliveryPricingDirector } from '@unchainedshop/core';
 
-export type HelperType<P, T> = (provider: DeliveryProviderType, params: P, context: Context) => T;
-
-export interface DeliveryProviderHelperTypes {
-  interface: HelperType<
-    never,
-    {
-      _id: string;
-      label: string;
-      version: string;
-    }
-  >;
-  isActive: HelperType<void, Promise<boolean>>;
-  configurationError: HelperType<never, Promise<DeliveryError>>;
-  simulatedPrice: HelperType<
-    {
-      currency?: string;
-      orderId: string;
-      useNetPrice?: boolean;
-      context: any;
-    },
-    Promise<{
-      amount: number;
-      currencyCode: string;
-      countryCode: string;
-      isTaxable: boolean;
-      isNetPrice: boolean;
-    }>
-  >;
-}
-
-export const DeliveryProvider: DeliveryProviderHelperTypes = {
-  interface(deliveryProvider) {
+export const DeliveryProvider = {
+  interface(deliveryProvider: DeliveryProviderType) {
     const Adapter = DeliveryDirector.getAdapter(deliveryProvider.adapterKey);
     if (!Adapter) return null;
     return {
@@ -43,29 +13,38 @@ export const DeliveryProvider: DeliveryProviderHelperTypes = {
     };
   },
 
-  async isActive(deliveryProvider, _, requestContext) {
+  async isActive(deliveryProvider: DeliveryProviderType, _: never, requestContext: Context) {
     const director = await DeliveryDirector.actions(deliveryProvider, {}, requestContext);
     return Boolean(director.isActive());
   },
 
-  async configurationError(deliveryProvider, _, requestContext) {
+  async configurationError(deliveryProvider: DeliveryProviderType, _: never, requestContext: Context) {
     const director = await DeliveryDirector.actions(deliveryProvider, {}, requestContext);
     return director.configurationError();
   },
 
   async simulatedPrice(
-    deliveryProvider,
-    { currency: currencyCode, orderId, useNetPrice, context: providerContext },
-    requestContext,
+    deliveryProvider: DeliveryProviderType,
+    {
+      currencyCode: forcedCurrencyCode,
+      orderId,
+      useNetPrice,
+      context: providerContext,
+    }: {
+      currencyCode?: string;
+      orderId: string;
+      useNetPrice?: boolean;
+      context: any;
+    },
+    requestContext: Context,
   ) {
-    const { modules, countryContext: country, user } = requestContext;
+    const { loaders, countryCode, user } = requestContext;
 
-    // TODO: use loader
-    const order = await modules.orders.findOrder({ orderId });
-    const currency = currencyCode || order?.currency || requestContext.currencyContext;
+    const order = await loaders.orderLoader.load({ orderId });
+    const currencyCode = forcedCurrencyCode || order?.currencyCode || requestContext.currencyCode;
     const pricingContext = {
-      country,
-      currency,
+      countryCode,
+      currencyCode,
       provider: deliveryProvider,
       order,
       providerContext,
@@ -80,13 +59,13 @@ export const DeliveryProvider: DeliveryProviderHelperTypes = {
 
     const orderPrice = pricing.total({ useNetPrice }) as {
       amount: number;
-      currency: string;
+      currencyCode: string;
     };
 
     return {
       amount: orderPrice.amount,
-      currencyCode: orderPrice.currency,
-      countryCode: country,
+      currencyCode: orderPrice.currencyCode,
+      countryCode,
       isTaxable: pricing.taxSum() > 0,
       isNetPrice: useNetPrice,
     };

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

@@ -1,16 +1,10 @@
 import { Context } from '../../../context.js';
-import { DeliveryProvider } from '@unchainedshop/core-delivery';
 import { Enrollment } from '@unchainedshop/core-enrollments';
 
-type HelperType<T> = (enrollmentDelivery: Enrollment['delivery'], _: never, context: Context) => T;
-
-type EnrollmentDeliveryHelperTypes = {
-  provider: HelperType<Promise<DeliveryProvider>>;
-};
-
-export const EnrollmentDelivery: EnrollmentDeliveryHelperTypes = {
-  provider: async ({ deliveryProviderId }, _, { modules }) => {
-    // TODO: use loader
-    return modules.delivery.findProvider({ deliveryProviderId });
+export const EnrollmentDelivery = {
+  provider: async ({ deliveryProviderId }: Enrollment['delivery'], _: never, { loaders }: Context) => {
+    return loaders.deliveryProviderLoader.load({
+      deliveryProviderId,
+    });
   },
 };

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

@@ -1,17 +1,9 @@
 import { Context } from '../../../context.js';
-import { PaymentProvider } from '@unchainedshop/core-payment';
 import { Enrollment } from '@unchainedshop/core-enrollments';
 
-type HelperType<T> = (enrollmentPayment: Enrollment['payment'], _: never, context: Context) => T;
-
-type EnrollmentPaymentHelperTypes = {
-  provider: HelperType<Promise<PaymentProvider>>;
-};
-
-export const EnrollmentPayment: EnrollmentPaymentHelperTypes = {
-  provider: async ({ paymentProviderId }, _, { modules }) => {
-    // TODO: use loader
-    return modules.payment.paymentProviders.findProvider({
+export const EnrollmentPayment = {
+  provider: async ({ paymentProviderId }: Enrollment['payment'], _: never, { loaders }: Context) => {
+    return loaders.paymentProviderLoader.load({
       paymentProviderId,
     });
   },

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

@@ -1,16 +1,8 @@
 import { Context } from '../../../context.js';
 import { EnrollmentPeriod as EnrollmentPeriodType } from '@unchainedshop/core-enrollments';
-import { Order } from '@unchainedshop/core-orders';
 
-type HelperType<T> = (enrollmentPeriod: EnrollmentPeriodType, _: never, context: Context) => T;
-
-type EnrollmentPeriodHelperTypes = {
-  order: HelperType<Promise<Order>>;
-};
-
-export const EnrollmentPeriod: EnrollmentPeriodHelperTypes = {
-  order: async (period, _, { modules }) => {
-    // TODO: use loader
-    return modules.orders.findOrder({ orderId: period.orderId });
+export const EnrollmentPeriod = {
+  async order(period: EnrollmentPeriodType, _: never, { loaders }: Context) {
+    return loaders.orderLoader.load({ orderId: period.orderId });
   },
 };

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

@@ -1,18 +1,10 @@
 import { Context } from '../../../context.js';
 import { EnrollmentPlan as EnrollmentPlanType } from '@unchainedshop/core-enrollments';
-import { Product } from '@unchainedshop/core-products';
 
-type HelperType<T> = (enrollmentPlan: EnrollmentPlanType, _: never, context: Context) => T;
-
-type EnrollmentPlanHelperTypes = {
-  product: HelperType<Promise<Product>>;
-};
-
-export const EnrollmentPlan: EnrollmentPlanHelperTypes = {
-  product: async (plan, _, { loaders }) => {
-    const product = await loaders.productLoader.load({
+export const EnrollmentPlan = {
+  async product(plan: EnrollmentPlanType, _: never, { loaders }: Context) {
+    return loaders.productLoader.load({
       productId: plan.productId,
     });
-    return product;
   },
 };

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

@@ -1,25 +1,12 @@
 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';
-import { User } from '@unchainedshop/core-users';
+import { Enrollment as EnrollmentType } from '@unchainedshop/core-enrollments';
 
-type HelperType<P, T> = (enrollment: EnrollmentType, params: P, context: Context) => T;
-
-type EnrollmentHelperTypes = {
-  isExpired: HelperType<{ referenceDate?: Date }, boolean>;
-  plan: HelperType<never, EnrollmentPlan>;
-  user: HelperType<never, Promise<User>>;
-  country: HelperType<never, Promise<Country>>;
-  currency: HelperType<never, Promise<Currency>>;
-};
-
-export const Enrollment: EnrollmentHelperTypes = {
-  isExpired: (obj, params, { modules }) => {
+export const Enrollment = {
+  isExpired: (obj: EnrollmentType, params: { referenceDate?: Date }, { modules }: Context) => {
     return modules.enrollments.isExpired(obj, params);
   },
 
-  plan: ({ quantity, productId, configuration }) => {
+  plan: ({ quantity, productId, configuration }: EnrollmentType) => {
     return {
       quantity,
       productId,
@@ -27,12 +14,10 @@ export const Enrollment: EnrollmentHelperTypes = {
     };
   },
 
-  // TODO: use loader
-  country: (obj, _, { modules }) => modules.countries.findCountry({ isoCode: obj.countryCode }),
-
-  // TODO: use loader
-  currency: (obj, _, { modules }) => modules.currencies.findCurrency({ isoCode: obj.currencyCode }),
-
-  // TODO: use loader
-  user: (obj, _, { modules }) => modules.users.findUserById(obj.userId),
+  country: async (obj: EnrollmentType, _: never, { loaders }: Context) =>
+    loaders.currencyLoader.load({ isoCode: obj.countryCode }),
+  currency: async (obj: EnrollmentType, _: never, { loaders }: Context) =>
+    loaders.currencyLoader.load({ isoCode: obj.currencyCode }),
+  user: async (obj: EnrollmentType, _: never, { loaders }: Context) =>
+    loaders.userLoader.load({ userId: obj.userId }),
 };