@unchainedshop/utils 1.1.3 → 1.1.9

package/src/director/BaseDiscountAdapter.ts

@@ -0,0 +1,58 @@
+import { log, LogLevel } from '@unchainedshop/logger';
+
+import { IDiscountAdapter } from '@unchainedshop/types/discount';
+
+export const BaseDiscountAdapter: Omit<IDiscountAdapter, 'key' | 'label' | 'version'> = {
+  orderIndex: 0,
+
+  isManualAdditionAllowed: async () => {
+    return false;
+  },
+
+  // return true if a discount is allowed to get removed manually by a user
+  isManualRemovalAllowed: async () => {
+    return false;
+  },
+
+  actions: async () => ({
+    // return true if a discount is valid to be part of the order
+    // without input of a user. that could be a time based global discount
+    // like a 10% discount day
+    // if you return false, this discount will
+    // get removed from the order before any price calculation
+    // takes place.
+    // eslint-disable-next-line
+    isValidForSystemTriggering: async () => {
+      return false;
+    },
+
+    // return an arbitrary JSON serializable object with reservation data
+    // this method is called when a discount is added through a manual code and let's
+    // you manually deduct expendable discounts (coupon balances for ex.) before checkout
+    reserve: async () => {
+      return {};
+    },
+
+    // return void, allows you to free up any reservations in backend systems
+    release: async () => {
+      return null;
+    },
+
+    // return true if a discount is valid to be part of the order.
+    // if you return false, this discount will
+    // get removed from the order before any price calculation
+    // takes place.
+    isValidForCodeTriggering: async () => {
+      return false;
+    },
+
+    // returns the appropriate discount context for a calculation adapter
+    discountForPricingAdapterKey() {
+      return null;
+    },
+  }),
+
+  log(message: string, { level = LogLevel.Debug, ...options } = {}) {
+    return log(message, { level, ...options });
+  },
+};

package/src/director/BaseDiscountDirector.ts

@@ -0,0 +1,62 @@
+import { IDiscountAdapter, IDiscountDirector } from '@unchainedshop/types/discount';
+import { log } from '@unchainedshop/logger';
+import { BaseDirector } from './BaseDirector';
+
+export const BaseDiscountDirector = (directorName: string): IDiscountDirector => {
+  const baseDirector = BaseDirector<IDiscountAdapter>(directorName, {
+    adapterSortKey: 'orderIndex',
+  });
+
+  return {
+    ...baseDirector,
+
+    actions: async (discountContext, requestContext) => {
+      const context = { ...discountContext, ...requestContext };
+
+      return {
+        resolveDiscountKeyFromStaticCode: async (options) => {
+          if (!context.order) return null;
+
+          log(`DiscountDirector -> Find user discount for static code ${options?.code}`);
+
+          const discounts = await Promise.all(
+            baseDirector
+              .getAdapters()
+              .filter((Adapter) => Adapter.isManualAdditionAllowed(options?.code))
+              .map(async (Adapter) => {
+                const adapter = await Adapter.actions({ context });
+                return {
+                  key: Adapter.key,
+                  isValid: await adapter.isValidForCodeTriggering(options),
+                };
+              }),
+          );
+
+          return discounts.find(({ isValid }) => isValid === true)?.key;
+        },
+
+        async findSystemDiscounts() {
+          if (!context.order) return [];
+          const discounts = await Promise.all(
+            baseDirector.getAdapters().map(async (Adapter) => {
+              const adapter = await Adapter.actions({ context });
+              return {
+                key: Adapter.key,
+                isValid: await adapter.isValidForSystemTriggering(),
+              };
+            }),
+          );
+
+          const validDiscounts = discounts
+            .filter(({ isValid }) => isValid === true)
+            .map(({ key }) => key);
+
+          if (validDiscounts.length > 0) {
+            log(`DiscountDirector -> Found ${validDiscounts.length} system discounts`);
+          }
+          return validDiscounts;
+        },
+      };
+    },
+  };
+};

package/src/director/BasePricingAdapter.ts

@@ -0,0 +1,41 @@
+import {
+  BasePricingAdapterContext,
+  IPricingSheet,
+  IPricingAdapter,
+  PricingCalculation,
+  IPricingAdapterActions,
+} from '@unchainedshop/types/pricing';
+import { log, LogLevel } from '@unchainedshop/logger';
+
+export const BasePricingAdapter = <
+  Context extends BasePricingAdapterContext,
+  Calculation extends PricingCalculation,
+>(): IPricingAdapter<Context, Calculation, IPricingSheet<Calculation>> => ({
+  key: '',
+  label: '',
+  version: '',
+  orderIndex: 0,
+
+  isActivatedFor: () => {
+    return false;
+  },
+
+  actions: (params) => {
+    const calculation = [];
+    const actions: IPricingAdapterActions<Calculation, Context> = {
+      calculate: async () => {
+        return [];
+      },
+      getCalculation: () => calculation,
+      getContext: () => params.context,
+    };
+
+    return actions as IPricingAdapterActions<Calculation, Context> & {
+      resultSheet: () => IPricingSheet<Calculation>;
+    };
+  },
+
+  log(message: string, { level = LogLevel.Debug, ...options } = {}) {
+    return log(message, { level, ...options });
+  },
+});

package/src/director/BasePricingDirector.ts

@@ -0,0 +1,106 @@
+import { Discount } from '@unchainedshop/types/discount';
+import {
+  BasePricingAdapterContext,
+  BasePricingContext,
+  IPricingDirector,
+  IPricingAdapter,
+  IPricingSheet,
+  PricingCalculation,
+  IPricingAdapterActions,
+} from '@unchainedshop/types/pricing';
+import { log, LogLevel } from '@unchainedshop/logger';
+import { BaseDirector } from './BaseDirector';
+
+export const BasePricingDirector = <
+  DirectorContext extends BasePricingContext,
+  AdapterContext extends BasePricingAdapterContext,
+  Calculation extends PricingCalculation,
+  PricingAdapter extends IPricingAdapter<AdapterContext, Calculation, IPricingSheet<Calculation>>,
+>(
+  directorName: string,
+): IPricingDirector<
+  DirectorContext,
+  Calculation,
+  AdapterContext,
+  IPricingSheet<Calculation>,
+  PricingAdapter
+> => {
+  const baseDirector = BaseDirector<PricingAdapter>(directorName, {
+    adapterSortKey: 'orderIndex',
+  });
+
+  const director: IPricingDirector<
+    DirectorContext,
+    Calculation,
+    AdapterContext,
+    IPricingSheet<Calculation>,
+    PricingAdapter
+  > = {
+    ...baseDirector,
+    buildPricingContext: async () => {
+      return {} as AdapterContext;
+    },
+    actions: async (pricingContext, requestContext, buildPricingContext) => {
+      const context = await buildPricingContext(pricingContext, requestContext);
+
+      let calculation: Array<Calculation> = [];
+
+      const actions: IPricingAdapterActions<Calculation, AdapterContext> = {
+        async calculate() {
+          const Adapters = baseDirector.getAdapters({
+            adapterFilter: (Adapter) => {
+              return Adapter.isActivatedFor(context);
+            },
+          });
+
+          calculation = await Adapters.reduce(async (previousPromise, Adapter) => {
+            const resolvedCalculation = await previousPromise;
+            if (!resolvedCalculation) return null;
+
+            const discounts: Array<Discount> = await Promise.all(
+              context.discounts.map(async (discount) => ({
+                discountId: discount._id,
+                configuration: await context.modules.orders.discounts.configurationForPricingAdapterKey(
+                  discount,
+                  Adapter.key,
+                  this.calculationSheet(),
+                  context,
+                ),
+              })),
+            );
+
+            try {
+              const adapter = Adapter.actions({
+                context,
+                calculationSheet: this.calculationSheet(),
+                discounts: discounts.filter(({ configuration }) => configuration !== null),
+              });
+
+              const nextCalculationResult = await adapter.calculate();
+              if (!nextCalculationResult) return null;
+              calculation = resolvedCalculation.concat(nextCalculationResult);
+              return calculation;
+            } catch (error) {
+              log(error, { level: LogLevel.Error });
+            }
+            return resolvedCalculation;
+          }, Promise.resolve([]));
+
+          return calculation;
+        },
+        getCalculation() {
+          return calculation;
+        },
+        getContext() {
+          return context;
+        },
+      };
+
+      return actions as IPricingAdapterActions<Calculation, AdapterContext> & {
+        calculationSheet: () => IPricingSheet<Calculation>;
+      };
+    },
+  };
+
+  return director;
+};

package/src/director/BasePricingSheet.ts

@@ -0,0 +1,78 @@
+import { PricingCalculation, IBasePricingSheet, PricingSheetParams } from '@unchainedshop/types/pricing';
+
+export const BasePricingSheet = <Calculation extends PricingCalculation>(
+  params: PricingSheetParams<Calculation>,
+): IBasePricingSheet<Calculation> => {
+  const calculation = params.calculation || [];
+
+  const pricingSheet: IBasePricingSheet<Calculation> = {
+    calculation,
+    currency: params.currency,
+    quantity: params.quantity,
+
+    getRawPricingSheet() {
+      return calculation;
+    },
+
+    isValid() {
+      return calculation.length > 0;
+    },
+
+    sum(filter) {
+      return this.filterBy(filter)
+        .filter(Boolean)
+        .reduce((sum: number, calculationRow: Calculation) => sum + calculationRow.amount, 0);
+    },
+
+    taxSum() {
+      return 0;
+    },
+
+    gross() {
+      return this.sum();
+    },
+
+    net() {
+      return this.gross() - this.taxSum();
+    },
+
+    total({ category, useNetPrice } = { useNetPrice: false }) {
+      if (!category) {
+        return {
+          amount: Math.round(useNetPrice ? this.net() : this.gross()),
+          currency: params.currency,
+        };
+      }
+
+      return {
+        amount: Math.round(this.sum({ category } as any)),
+        currency: params.currency,
+      };
+    },
+
+    filterBy(filter) {
+      const filteredCalculation = Object.keys(filter || {}).reduce(
+        (oldCalculation, filterKey) =>
+          oldCalculation.filter(
+            (row: Calculation) =>
+              !!row && (filter[filterKey] === undefined || row[filterKey] === filter[filterKey]),
+          ),
+        calculation,
+      );
+
+      return filteredCalculation;
+    },
+
+    resetCalculation(calculationSheet) {
+      calculationSheet.filterBy().forEach(({ amount, ...row }: Calculation) => {
+        pricingSheet.calculation.push({
+          ...row,
+          amount: amount * -1,
+        } as Calculation);
+      });
+      return pricingSheet.calculation;
+    },
+  };
+
+  return pricingSheet;
+};

package/src/find-localized-text.js

@@ -0,0 +1,50 @@
+import 'abort-controller/polyfill';
+import LRU from 'lru-cache';
+import { systemLocale } from './locale-helpers';
+
+const { NODE_ENV } = process.env;
+
+const ttl = NODE_ENV === 'production' ? 1000 * 30 : 0; // 30 seconds or 1 second
+
+const textCache = new LRU({ max: 50000, ttl });
+
+const extendSelectorWithLocale = (selector, locale) => {
+  const localeSelector = {
+    locale: { $in: [locale.normalized, locale.language] },
+  };
+  return { ...localeSelector, ...selector };
+};
+
+const findLocalizedText = async (collection, selector, locale) => {
+  const cacheKey = JSON.stringify({
+    n: collection._name, // eslint-disable-line
+    s: selector,
+    l: locale,
+  });
+
+  const cachedText = textCache.get(cacheKey);
+
+  if (cachedText) return cachedText;
+
+  const exactTranslation = await collection.findOne(extendSelectorWithLocale(selector, locale));
+  if (exactTranslation) {
+    textCache.set(cacheKey, exactTranslation);
+    return exactTranslation;
+  }
+
+  if (systemLocale.normalized !== locale.normalized) {
+    const fallbackTranslation = await collection.findOne(
+      extendSelectorWithLocale(selector, systemLocale),
+    );
+    if (fallbackTranslation) {
+      textCache.set(cacheKey, fallbackTranslation);
+      return fallbackTranslation;
+    }
+  }
+
+  const foundText = await collection.findOne(selector, {});
+  textCache.set(cacheKey, foundText);
+  return foundText;
+};
+
+export default findLocalizedText;

package/src/find-preserving-ids.ts

@@ -0,0 +1,42 @@
+import { Collection, FindOptions, Query } from '@unchainedshop/types/common';
+
+const { AMAZON_DOCUMENTDB_COMPAT_MODE } = process.env;
+
+const sortByIndex = {
+  index: 1,
+};
+
+const sortBySequence = {
+  sequence: 1,
+};
+
+const defaultSort = AMAZON_DOCUMENTDB_COMPAT_MODE ? sortBySequence : sortByIndex;
+
+export const findPreservingIds =
+  <T>(collection: Collection<T>) =>
+  async (selector: Query, ids: Array<string>, options?: FindOptions): Promise<Array<T>> => {
+    const { skip, limit, sort = defaultSort } = options || {};
+    const filteredSelector = {
+      ...selector,
+      _id: { $in: ids },
+    };
+
+    const filteredPipeline = [
+      {
+        $match: filteredSelector,
+      },
+      typeof sort === 'object' &&
+        'index' in sort && {
+          $addFields: {
+            index: { $indexOfArray: [ids, '$_id'] },
+          },
+        },
+      sort && { $sort: sort },
+      skip && { $skip: skip },
+      limit && { $limit: limit },
+    ].filter(Boolean);
+
+    const aggregationPointer = collection.aggregate(filteredPipeline);
+    const items = await aggregationPointer.toArray();
+    return items as Array<T>;
+  };

package/src/find-unused-slug.js

@@ -0,0 +1,26 @@
+const DELIMITER = '-';
+
+const addSuffixToSlug = (slug, index = 1, delimiter = DELIMITER) => {
+  return `${slug}${delimiter}${index}`;
+};
+
+const incrementSuffixedSlug = (slugIncludingSuffix, delimiter = DELIMITER) => {
+  const slugParts = slugIncludingSuffix.split(delimiter);
+  const suffixedIndex = parseInt(slugParts.pop(), 10);
+  const slugWithoutSuffix = slugParts.join(delimiter);
+  return addSuffixToSlug(slugWithoutSuffix, suffixedIndex + 1);
+};
+
+export default (checkSlugIsUniqueFn, { slugify }) => {
+  const findUnusedSlug = async ({ title, existingSlug, newSlug }) => {
+    const slug = newSlug || existingSlug || `${slugify(title)}`;
+    if (!(await checkSlugIsUniqueFn(slug))) {
+      const isSlugAlreadySuffixed = !!newSlug;
+      return findUnusedSlug({
+        newSlug: isSlugAlreadySuffixed ? incrementSuffixedSlug(slug) : addSuffixToSlug(slug),
+      });
+    }
+    return slug;
+  };
+  return findUnusedSlug;
+};

package/src/generate-random-hash.ts

@@ -0,0 +1,8 @@
+import Hashids from 'hashids';
+
+const hashids = new Hashids('unchained', 6, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890');
+
+export default () => {
+  const randomNumber = Math.floor(Math.random() * (999999999 - 1)) + 1;
+  return hashids.encode(randomNumber);
+};

package/src/locale-helpers.js

@@ -0,0 +1,43 @@
+import localePkg from 'locale';
+
+const { Locales, Locale } = localePkg;
+
+const { UNCHAINED_LANG = 'de', UNCHAINED_COUNTRY = 'CH' } = process.env;
+
+export const systemLocale = new Locale(`${UNCHAINED_LANG}-${UNCHAINED_COUNTRY}`);
+
+export const resolveBestSupported = (acceptLanguage, supportedLocales) => {
+  const acceptLocale = new Locales(acceptLanguage);
+  const bestLocale = acceptLocale.best(supportedLocales);
+  if (!bestLocale) return systemLocale;
+  return bestLocale;
+};
+
+export const resolveBestCountry = (localeCountry, shopCountry, countries) => {
+  if (shopCountry) {
+    const resolvedCountry = countries.reduce((lastResolved, country) => {
+      if (shopCountry === country.isoCode) {
+        return country.isoCode;
+      }
+      return lastResolved;
+    }, null);
+    if (resolvedCountry) {
+      return resolvedCountry;
+    }
+  }
+  return localeCountry || systemLocale.country;
+};
+
+export const resolveUserRemoteAddress = (req) => {
+  const remoteAddress =
+    req.headers['x-real-ip'] ||
+    req.headers['x-forwarded-for'] ||
+    req.connection.remoteAddress ||
+    req.socket.remoteAddress ||
+    req.connection.socket.remoteAddress;
+
+  const remotePort =
+    req.connection?.remotePort || req.socket?.remotePort || req.connection?.socket?.remotePort;
+
+  return { remoteAddress, remotePort };
+};

package/src/object-invert.js

@@ -0,0 +1,8 @@
+const invertMapObject = (theMapObject) =>
+  Object.keys(theMapObject).reduce((invertedObj, key) => {
+    const newObj = invertedObj;
+    newObj[theMapObject[key]] = key;
+    return newObj;
+  }, {});
+
+export default invertMapObject;

package/src/pipe-promises.js

@@ -0,0 +1,2 @@
+export default (fns) => (initialValue) =>
+  fns.reduce((sum, fn) => Promise.resolve(sum).then(fn), initialValue);

package/src/random-value-hex.ts

@@ -0,0 +1,8 @@
+import crypto from 'crypto';
+
+export default function randomValueHex(len: number): string {
+  return crypto
+    .randomBytes(Math.ceil(len / 2))
+    .toString('hex') // convert to hexadecimal format
+    .slice(0, len); // return required number of characters
+}

package/src/schemas/AddressSchema.js

@@ -0,0 +1,16 @@
+import SimpleSchema from 'simpl-schema';
+
+export const AddressSchema = new SimpleSchema(
+  {
+    firstName: String,
+    lastName: String,
+    company: String,
+    addressLine: String,
+    addressLine2: String,
+    city: String,
+    postalCode: String,
+    regionCode: String,
+    countryCode: String,
+  },
+  { requiredByDefault: false },
+);

package/src/schemas/ContactSchema.js

@@ -0,0 +1,9 @@
+import SimpleSchema from 'simpl-schema';
+
+export const ContactSchema = new SimpleSchema(
+  {
+    telNumber: String,
+    emailAddress: String,
+  },
+  { requiredByDefault: false },
+);

package/src/schemas/UsersSchema.js

@@ -0,0 +1,67 @@
+import SimpleSchema from 'simpl-schema';
+import { AddressSchema } from './AddressSchema';
+import { timestampFields } from './commonSchemaFields';
+
+const ProfileSchema = new SimpleSchema(
+  {
+    displayName: String,
+    birthday: Date,
+    phoneMobile: String,
+    gender: String,
+    address: AddressSchema,
+  },
+  { requiredByDefault: false },
+);
+
+export const LastLoginSchema = new SimpleSchema(
+  {
+    timestamp: Date,
+    locale: String,
+    countryContext: String,
+    remoteAddress: String,
+    remotePort: String,
+    userAgent: String,
+  },
+  { requiredByDefault: false },
+);
+
+export const LastContactSchema = new SimpleSchema(
+  {
+    telNumber: String,
+    emailAddress: String,
+  },
+  { requiredByDefault: false },
+);
+
+export const UserSchema = new SimpleSchema(
+  {
+    emails: Array,
+    'emails.$': Object,
+    'emails.$.address': String,
+    'emails.$.verified': Boolean,
+    username: String,
+    lastLogin: LastLoginSchema,
+    profile: ProfileSchema,
+    lastBillingAddress: AddressSchema,
+    lastContact: LastContactSchema,
+    guest: Boolean,
+    initialPassword: Boolean,
+    tags: Array,
+    'tags.$': String,
+    avatarId: String,
+    meta: {
+      type: Object,
+      optional: true,
+      blackbox: true,
+    },
+    services: {
+      type: Object,
+      optional: true,
+      blackbox: true,
+    },
+    roles: Array,
+    'roles.$': String,
+    ...timestampFields,
+  },
+  { requiredByDefault: false },
+);

package/src/schemas/commonSchemaFields.js

@@ -0,0 +1,32 @@
+export const contextFields = {
+  context: {
+    type: Object,
+    blackbox: true,
+    required: false,
+  },
+};
+
+export const logFields = {
+  log: Array,
+  'log.$': {
+    type: Object,
+  },
+  'log.$.date': {
+    type: Date,
+  },
+  'log.$.status': {
+    type: String,
+  },
+  'log.$.info': {
+    type: String,
+  },
+};
+
+export const timestampFields = {
+  created: { type: Date, required: true },
+  createdBy: { type: String }, // Logically it is required but for backwards compatibility it's set to optional
+  updated: { type: Date },
+  updatedBy: { type: String },
+  deleted: { type: Date },
+  deletedBy: { type: String },
+};

package/src/slugify.js

@@ -0,0 +1,10 @@
+export default function slugify(text) {
+  return text
+    .toString()
+    .toLowerCase()
+    .replace(/\s+/g, '-') // Replace spaces with -
+    .replace(/[^\w-]+/g, '') // Remove all non-word chars
+    .replace(/--+/g, '-') // Replace multiple - with single -
+    .replace(/^-+/, '') // Trim - from start of text
+    .replace(/-+$/, ''); // Trim - from end of text
+}