@unchainedshop/api 4.2.2 → 4.3.1

package/src/mongo-store.ts

@@ -0,0 +1,500 @@
+/* 
+  MIT License
+  Fork of https://github.com/jdesboeufs/connect-mongo#readme Connect Mongo 
+  Thanks to Casey Banner, Jerome Desboeufs, MC Or
+*/
+
+import { assert } from 'node:console';
+import util from 'node:util';
+import * as session from 'express-session';
+import { Collection, MongoClient, MongoClientOptions, WriteConcernSettings } from 'mongodb';
+import { createLogger } from '@unchainedshop/logger';
+
+const logger = createLogger('unchained:api');
+
+export interface CryptoOptions {
+  secret: false | string;
+  algorithm?: string;
+  hashing?: string;
+  encodeas?: string;
+  key_size?: number;
+  iv_size?: number;
+  at_size?: number;
+}
+
+export interface ConnectMongoOptions {
+  mongoUrl?: string;
+  clientPromise?: Promise<MongoClient>;
+  client?: MongoClient;
+  collectionName?: string;
+  mongoOptions?: MongoClientOptions;
+  dbName?: string;
+  ttl?: number;
+  touchAfter?: number;
+  stringify?: boolean;
+  createAutoRemoveIdx?: boolean;
+  autoRemove?: 'native' | 'interval' | 'disabled';
+  autoRemoveInterval?: number;
+  // FIXME: remove those any
+  serialize?: (a: any) => any;
+  unserialize?: (a: any) => any;
+  writeOperationOptions?: WriteConcernSettings;
+  transformId?: (a: any) => any;
+}
+
+type ConcretCryptoOptions = Required<CryptoOptions>;
+
+interface ConcretConnectMongoOptions {
+  mongoUrl?: string;
+  clientPromise?: Promise<MongoClient>;
+  client?: MongoClient;
+  collectionName: string;
+  mongoOptions: MongoClientOptions;
+  dbName?: string;
+  ttl: number;
+  createAutoRemoveIdx?: boolean;
+  autoRemove: 'native' | 'interval' | 'disabled';
+  autoRemoveInterval: number;
+  touchAfter: number;
+  stringify: boolean;
+  // FIXME: remove those any
+  serialize?: (a: any) => any;
+  unserialize?: (a: any) => any;
+  writeOperationOptions?: WriteConcernSettings;
+  transformId?: (a: any) => any;
+  // FIXME: remove above any
+  crypto: ConcretCryptoOptions;
+}
+
+interface InternalSessionType {
+  _id: string;
+  session: any;
+  expires?: Date;
+  lastModified?: Date;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-empty-function
+const noop = () => {};
+const unit: <T>(a: T) => T = (a) => a;
+
+function defaultSerializeFunction(session: session.SessionData): session.SessionData {
+  // Copy each property of the session to a new object
+  const obj = {};
+  let prop;
+  for (prop in session) {
+    if (prop === 'cookie') {
+      // Convert the cookie instance to an object, if possible
+      // This gets rid of the duplicate object under session.cookie.data property
+      // @ts-expect-error FIXME:
+      obj.cookie = session.cookie.toJSON ? session.cookie.toJSON() : session.cookie;
+    } else {
+      obj[prop] = session[prop];
+    }
+  }
+
+  return obj as session.SessionData;
+}
+
+function computeTransformFunctions(options: ConcretConnectMongoOptions) {
+  if (options.serialize || options.unserialize) {
+    return {
+      serialize: options.serialize || defaultSerializeFunction,
+      unserialize: options.unserialize || unit,
+    };
+  }
+
+  if (options.stringify === false) {
+    return {
+      serialize: defaultSerializeFunction,
+      unserialize: unit,
+    };
+  }
+  // Default case
+  return {
+    serialize: JSON.stringify,
+    unserialize: JSON.parse,
+  };
+}
+
+export default class MongoStore extends session.Store {
+  private clientP: Promise<MongoClient>;
+  private crypto: any = null;
+  private timer?: NodeJS.Timeout;
+  collectionP: Promise<Collection<InternalSessionType>>;
+  private options: ConcretConnectMongoOptions;
+  // FIXME: remvoe any
+  private transformFunctions: {
+    serialize: (a: any) => any;
+    unserialize: (a: any) => any;
+  };
+
+  constructor({
+    collectionName = 'sessions',
+    ttl = 1209600,
+    mongoOptions = {},
+    autoRemove = 'native',
+    autoRemoveInterval = 10,
+    touchAfter = 0,
+    stringify = true,
+    ...required
+  }: ConnectMongoOptions) {
+    super();
+    logger.debug('create MongoStore instance');
+    const options: ConcretConnectMongoOptions = {
+      collectionName,
+      ttl,
+      mongoOptions,
+      autoRemove,
+      autoRemoveInterval,
+      touchAfter,
+      stringify,
+      crypto: {
+        secret: false,
+        algorithm: 'aes-256-gcm',
+        hashing: 'sha512',
+        encodeas: 'base64',
+        key_size: 32,
+        iv_size: 16,
+        at_size: 16,
+      },
+      ...required,
+    };
+    // Check params
+    assert(
+      options.mongoUrl || options.clientPromise || options.client,
+      'You must provide either mongoUrl|clientPromise|client in options',
+    );
+    assert(
+      options.createAutoRemoveIdx === null || options.createAutoRemoveIdx === undefined,
+      'options.createAutoRemoveIdx has been reverted to autoRemove and autoRemoveInterval',
+    );
+    assert(
+      !options.autoRemoveInterval || options.autoRemoveInterval <= 71582,
+      /* (Math.pow(2, 32) - 1) / (1000 * 60) */ 'autoRemoveInterval is too large. options.autoRemoveInterval is in minutes but not seconds nor mills',
+    );
+    this.transformFunctions = computeTransformFunctions(options);
+    let _clientP: Promise<MongoClient>;
+    if (options.mongoUrl) {
+      _clientP = MongoClient.connect(options.mongoUrl, options.mongoOptions);
+    } else if (options.clientPromise) {
+      _clientP = options.clientPromise;
+    } else if (options.client) {
+      _clientP = Promise.resolve(options.client);
+    } else {
+      throw new Error('Cannot init client. Please provide correct options');
+    }
+    assert(!!_clientP, 'Client is null|undefined');
+    this.clientP = _clientP;
+    this.options = options;
+    this.collectionP = _clientP.then(async (con) => {
+      const collection = con.db(options.dbName).collection<InternalSessionType>(options.collectionName);
+      await this.setAutoRemove(collection);
+      return collection;
+    });
+  }
+
+  static create(options: ConnectMongoOptions): MongoStore {
+    return new MongoStore(options);
+  }
+
+  private setAutoRemove(collection: Collection<InternalSessionType>): Promise<unknown> {
+    const removeQuery = () => ({
+      expires: {
+        $lt: new Date(),
+      },
+    });
+    switch (this.options.autoRemove) {
+      case 'native':
+        logger.debug('Creating MongoDB TTL index');
+        return collection.createIndex(
+          { expires: 1 },
+          {
+            background: true,
+            expireAfterSeconds: 0,
+          },
+        );
+      case 'interval':
+        logger.debug('create Timer to remove expired sessions');
+        this.timer = setInterval(
+          () =>
+            collection.deleteMany(removeQuery(), {
+              writeConcern: {
+                w: 0,
+                j: false,
+              },
+            }),
+          this.options.autoRemoveInterval * 1000 * 60,
+        );
+        this.timer.unref();
+        return Promise.resolve();
+      case 'disabled':
+      default:
+        return Promise.resolve();
+    }
+  }
+
+  private computeStorageId(sessionId: string) {
+    if (this.options.transformId && typeof this.options.transformId === 'function') {
+      return this.options.transformId(sessionId);
+    }
+    return sessionId;
+  }
+
+  /**
+   * promisify and bind the `this.crypto.get` function.
+   * Please check !!this.crypto === true before using this getter!
+   */
+  private get cryptoGet() {
+    if (!this.crypto) {
+      throw new Error('Check this.crypto before calling this.cryptoGet!');
+    }
+    return util.promisify(this.crypto.get).bind(this.crypto);
+  }
+
+  /**
+   * Decrypt given session data
+   * @param session session data to be decrypt. Mutate the input session.
+   */
+  private async decryptSession(session: session.SessionData | undefined | null) {
+    if (this.crypto && session) {
+      const plaintext = await this.cryptoGet(
+        this.options.crypto.secret as string,
+        (session as any).session,
+      ).catch((err: any) => {
+        throw new Error(err);
+      });
+      (session as any).session = JSON.parse(plaintext);
+    }
+  }
+
+  /**
+   * Get a session from the store given a session ID (sid)
+   * @param sid session ID
+   */
+  get(sid: string, callback: (err: any, session?: session.SessionData | null) => void): void {
+    (async () => {
+      try {
+        logger.debug(`MongoStore#get=${sid}`);
+        const collection = await this.collectionP;
+        const session = await collection.findOne({
+          _id: this.computeStorageId(sid),
+          $or: [{ expires: { $exists: false } }, { expires: { $gt: new Date() } }],
+        });
+        if (this.crypto && session) {
+          await this.decryptSession(session as unknown as session.SessionData).catch((err) =>
+            callback(err),
+          );
+        }
+        const s = session && this.transformFunctions.unserialize(session.session);
+        if (this.options.touchAfter > 0 && session?.lastModified) {
+          s.lastModified = session.lastModified;
+        }
+        this.emit('get', sid);
+        callback(null, s === undefined ? null : s);
+      } catch (error) {
+        callback(error);
+      }
+    })();
+  }
+
+  /**
+   * Upsert a session into the store given a session ID (sid) and session (session) object.
+   * @param sid session ID
+   * @param session session object
+   */
+  set(sid: string, session: session.SessionData, callback: (err: any) => void = noop): void {
+    (async () => {
+      try {
+        logger.debug(`MongoStore#set=${sid}`);
+        // Removing the lastModified prop from the session object before update
+        // @ts-expect-error Session not typed
+        if (this.options.touchAfter > 0 && session?.lastModified) {
+          // @ts-expect-error Session not typed
+          delete session.lastModified;
+        }
+        const s: InternalSessionType = {
+          _id: this.computeStorageId(sid),
+          session: this.transformFunctions.serialize(session),
+        };
+        // Expire handling
+        if (session?.cookie?.expires) {
+          s.expires = new Date(session.cookie.expires);
+        } else {
+          // If there's no expiration date specified, it is
+          // browser-session cookie or there is no cookie at all,
+          // as per the connect docs.
+          //
+          // So we set the expiration to two-weeks from now
+          // - as is common practice in the industry (e.g Django) -
+          // or the default specified in the options.
+          s.expires = new Date(Date.now() + this.options.ttl * 1000);
+        }
+        // Last modify handling
+        if (this.options.touchAfter > 0) {
+          s.lastModified = new Date();
+        }
+        if (this.crypto) {
+          const cryptoSet = util.promisify(this.crypto.set).bind(this.crypto);
+          const data = await cryptoSet(this.options.crypto.secret as string, s.session).catch(
+            (err: any) => {
+              throw new Error(err);
+            },
+          );
+          s.session = data as unknown as session.SessionData;
+        }
+        const collection = await this.collectionP;
+        const rawResp = await collection.updateOne(
+          { _id: s._id },
+          { $set: s },
+          {
+            upsert: true,
+            writeConcern: this.options.writeOperationOptions,
+          },
+        );
+        if (rawResp.upsertedCount > 0) {
+          this.emit('create', sid);
+        } else {
+          this.emit('update', sid);
+        }
+        this.emit('set', sid);
+      } catch (error) {
+        return callback(error);
+      }
+      return callback(null);
+    })();
+  }
+
+  touch(
+    sid: string,
+    session: session.SessionData & { lastModified?: Date },
+    callback: (err: any) => void = noop,
+  ): void {
+    (async () => {
+      try {
+        logger.debug(`MongoStore#touch=${sid}`);
+        const updateFields: {
+          lastModified?: Date;
+          expires?: Date;
+          session?: session.SessionData;
+        } = {};
+        const touchAfter = this.options.touchAfter * 1000;
+        const lastModified = session.lastModified ? session.lastModified.getTime() : 0;
+        const currentDate = new Date();
+
+        // If the given options has a touchAfter property, check if the
+        // current timestamp - lastModified timestamp is bigger than
+        // the specified, if it's not, don't touch the session
+        if (touchAfter > 0 && lastModified > 0) {
+          const timeElapsed = currentDate.getTime() - lastModified;
+          if (timeElapsed < touchAfter) {
+            logger.debug(`Skip touching session=${sid}`);
+            return callback(null);
+          }
+          updateFields.lastModified = currentDate;
+        }
+
+        if (session?.cookie?.expires) {
+          updateFields.expires = new Date(session.cookie.expires);
+        } else {
+          updateFields.expires = new Date(Date.now() + this.options.ttl * 1000);
+        }
+        const collection = await this.collectionP;
+        const rawResp = await collection.updateOne(
+          { _id: this.computeStorageId(sid) },
+          { $set: updateFields },
+          { writeConcern: this.options.writeOperationOptions },
+        );
+        if (rawResp.matchedCount === 0) {
+          return callback(new Error('Unable to find the session to touch'));
+        } else {
+          this.emit('touch', sid, session);
+          return callback(null);
+        }
+      } catch (error) {
+        return callback(error);
+      }
+    })();
+  }
+
+  /**
+   * Get all sessions in the store as an array
+   */
+  all(
+    callback: (
+      err: any,
+      obj?: session.SessionData[] | Record<string, session.SessionData> | null,
+    ) => void,
+  ): void {
+    (async () => {
+      try {
+        logger.debug('MongoStore#all()');
+        const collection = await this.collectionP;
+        const sessions = collection.find({
+          $or: [{ expires: { $exists: false } }, { expires: { $gt: new Date() } }],
+        });
+        const results: session.SessionData[] = [];
+        for await (const session of sessions) {
+          if (this.crypto && session) {
+            await this.decryptSession(session as unknown as session.SessionData);
+          }
+          results.push(this.transformFunctions.unserialize(session.session));
+        }
+        this.emit('all', results);
+        callback(null, results);
+      } catch (error) {
+        callback(error);
+      }
+    })();
+  }
+
+  /**
+   * Destroy/delete a session from the store given a session ID (sid)
+   * @param sid session ID
+   */
+  destroy(sid: string, callback: (err: any) => void = noop): void {
+    logger.debug(`MongoStore#destroy=${sid}`);
+    this.collectionP
+      .then((colleciton) =>
+        colleciton.deleteOne(
+          { _id: this.computeStorageId(sid) },
+          { writeConcern: this.options.writeOperationOptions },
+        ),
+      )
+      .then(() => {
+        this.emit('destroy', sid);
+        callback(null);
+      })
+      .catch((err) => callback(err));
+  }
+
+  /**
+   * Get the count of all sessions in the store
+   */
+  length(callback: (err: any, length: number) => void): void {
+    logger.debug('MongoStore#length()');
+    this.collectionP
+      .then((collection) => collection.countDocuments())
+      .then((c) => callback(null, c))
+      // @ts-expect-error Callback wrong type
+      .catch((err) => callback(err));
+  }
+
+  /**
+   * Delete all sessions from the store.
+   */
+  clear(callback: (err: any) => void = noop): void {
+    logger.debug('MongoStore#clear()');
+    this.collectionP
+      .then((collection) => collection.drop())
+      .then(() => callback(null))
+      .catch((err) => callback(err));
+  }
+
+  /**
+   * Close database connection
+   */
+  close(): Promise<void> {
+    logger.debug('MongoStore#close()');
+    return this.clientP.then((c) => c.close());
+  }
+}

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

@@ -0,0 +1,55 @@
+import { DeliveryDirector, DeliveryPricingDirector } from '@unchainedshop/core';
+import { Context } from '../../context.js';
+
+export const DeliveryProviderInterface = {
+  async isActive(deliveryProvider, _, context: Context) {
+    const director = await DeliveryDirector.actions(deliveryProvider, {}, context);
+    return Boolean(director.isActive());
+  },
+
+  async configurationError(deliveryProvider, _, context: Context) {
+    const director = await DeliveryDirector.actions(deliveryProvider, {}, context);
+    return director.configurationError();
+  },
+
+  interface(deliveryProvider) {
+    const Adapter = DeliveryDirector.getAdapter(deliveryProvider.adapterKey);
+    if (!Adapter) return null;
+    return {
+      _id: Adapter.key,
+      label: Adapter.label,
+      version: Adapter.version,
+    };
+  },
+
+  async simulatedPrice(deliveryProvider, args, context: Context) {
+    const { loaders, countryCode, user } = context;
+    const { currencyCode: forcedCurrencyCode, orderId, useNetPrice, context: providerContext } = args;
+
+    const order = await loaders.orderLoader.load({ orderId });
+    const currencyCode = forcedCurrencyCode || order?.currencyCode || context.currencyCode;
+
+    const pricingContext = {
+      countryCode,
+      currencyCode,
+      provider: deliveryProvider,
+      order,
+      providerContext,
+      user: user!,
+    };
+
+    const calculated = await DeliveryPricingDirector.rebuildCalculation(pricingContext, context);
+    if (!calculated?.length) return null;
+
+    const pricing = DeliveryPricingDirector.calculationSheet(pricingContext, calculated);
+    const orderPrice = pricing.total({ useNetPrice });
+
+    return {
+      amount: orderPrice.amount,
+      currencyCode: orderPrice.currencyCode,
+      countryCode,
+      isTaxable: pricing.taxSum() > 0,
+      isNetPrice: useNetPrice,
+    };
+  },
+};

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

@@ -0,0 +1,12 @@
+import { DeliveryDirector } from '@unchainedshop/core';
+import { Context } from '../../context.js';
+import { DeliveryProvider } from '@unchainedshop/core-delivery';
+import { DeliveryProviderInterface } from './delivery-provider-interface.js';
+
+export const DeliveryProviderPickUp = {
+  ...DeliveryProviderInterface,
+  async pickUpLocations(provider: DeliveryProvider, _: never, context: Context) {
+    const director = await DeliveryDirector.actions(provider, {}, context);
+    return director.pickUpLocations() || [];
+  },
+};

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

@@ -0,0 +1,5 @@
+import { DeliveryProviderInterface } from './delivery-provider-interface.js';
+
+export const DeliveryProviderShipping = {
+  ...DeliveryProviderInterface,
+};

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

@@ -1,73 +1,27 @@
 import { Context } from '../../context.js';
-import { DeliveryProvider as DeliveryProviderType } from '@unchainedshop/core-delivery';
-import { DeliveryDirector, DeliveryPricingDirector } from '@unchainedshop/core';
+import {
+  DeliveryProvider as DeliveryProviderActual,
+  DeliveryProviderType,
+} from '@unchainedshop/core-delivery';
+import { objectInvert } from '@unchainedshop/utils';
+import { DeliveryProviderInterface } from './delivery-provider-interface.js';
+
+const DeliveryProviderMap = {
+  DeliveryProviderShipping: DeliveryProviderType.SHIPPING,
+  DeliveryProviderPickUp: DeliveryProviderType.PICKUP,
+};
 
 export const DeliveryProvider = {
-  interface(deliveryProvider: DeliveryProviderType) {
-    const Adapter = DeliveryDirector.getAdapter(deliveryProvider.adapterKey);
-    if (!Adapter) return null;
-    return {
-      _id: Adapter.key,
-      label: Adapter.label,
-      version: Adapter.version,
-    };
-  },
-
-  async isActive(deliveryProvider: DeliveryProviderType, _: never, requestContext: Context) {
-    const director = await DeliveryDirector.actions(deliveryProvider, {}, requestContext);
-    return Boolean(director.isActive());
-  },
-
-  async configurationError(deliveryProvider: DeliveryProviderType, _: never, requestContext: Context) {
-    const director = await DeliveryDirector.actions(deliveryProvider, {}, requestContext);
-    return director.configurationError();
-  },
-
-  async simulatedPrice(
-    deliveryProvider: DeliveryProviderType,
-    {
-      currencyCode: forcedCurrencyCode,
-      orderId,
-      useNetPrice,
-      context: providerContext,
-    }: {
-      currencyCode?: string;
-      orderId: string;
-      useNetPrice?: boolean;
-      context: any;
-    },
-    requestContext: Context,
-  ) {
-    const { loaders, countryCode, user } = requestContext;
-
-    const order = await loaders.orderLoader.load({ orderId });
-    const currencyCode = forcedCurrencyCode || order?.currencyCode || requestContext.currencyCode;
-    const pricingContext = {
-      countryCode,
-      currencyCode,
-      provider: deliveryProvider,
-      order,
-      providerContext,
-      user: user!,
-    };
-
-    const calculated = await DeliveryPricingDirector.rebuildCalculation(pricingContext, requestContext);
-
-    if (!calculated || !calculated.length) return null;
-
-    const pricing = DeliveryPricingDirector.calculationSheet(pricingContext, calculated);
-
-    const orderPrice = pricing.total({ useNetPrice }) as {
-      amount: number;
-      currencyCode: string;
-    };
-
-    return {
-      amount: orderPrice.amount,
-      currencyCode: orderPrice.currencyCode,
-      countryCode,
-      isTaxable: pricing.taxSum() > 0,
-      isNetPrice: useNetPrice,
-    };
+  __resolveType: async (obj: DeliveryProviderActual, { loaders }: Context) => {
+    const provider = await loaders.deliveryProviderLoader.load({
+      deliveryProviderId: obj._id,
+    });
+
+    const invertedProductTypes = objectInvert(DeliveryProviderMap);
+    if (provider) {
+      return invertedProductTypes[provider.type];
+    }
+    return invertedProductTypes[DeliveryProviderType.SHIPPING];
   },
+  ...DeliveryProviderInterface,
 };

package/src/resolvers/type/index.ts

@@ -67,6 +67,8 @@ import { Web3Address } from './web3-address.js';
 import { LoginMethodResponse } from './login-method-response-types.js';
 import { ProductSearchResult } from './product-search-result-types.js';
 import { OrderStatistics } from './order/order-statistics-types.js';
+import { DeliveryProviderPickUp } from './delivery-provider-pickup-types.js';
+import { DeliveryProviderShipping } from './delivery-provider-shipping-types.js';
 
 const types = {
   Assortment,
@@ -81,6 +83,8 @@ const types = {
   Country,
   Currency,
   DeliveryProvider,
+  DeliveryProviderPickUp,
+  DeliveryProviderShipping,
   Dimensions,
   Enrollment,
   EnrollmentDelivery,

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

@@ -113,10 +113,9 @@ export const OrderItem = {
     return product;
   },
 
-  async quotation(orderPosition: OrderPosition, _, { modules }: Context): Promise<Quotation | null> {
+  async quotation(orderPosition: OrderPosition, _, { loaders }: Context): Promise<Quotation | null> {
     if (!orderPosition.quotationId) return null;
-    // TODO: use quotation loader
-    return modules.quotations.findQuotation({ quotationId: orderPosition.quotationId });
+    return loaders.quotationLoader.load({ quotationId: orderPosition.quotationId });
   },
 
   async total(