@unchainedshop/utils 1.1.4 → 1.2.0

package/jest.config.js

@@ -0,0 +1,5 @@
+/** @type {import('ts-jest/dist/types').InitialOptionsTsJest} */
+export default {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+};

package/lib/generate-random-hash.d.ts

@@ -1,2 +1,2 @@
-declare function _default(): string;
+declare const _default: () => string;
 export default _default;

package/lib/generate-random-hash.js

@@ -1,4 +1,4 @@
-import Hashids from 'hashids/cjs';
+import Hashids from 'hashids';
 const hashids = new Hashids('unchained', 6, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890');
 export default () => {
     const randomNumber = Math.floor(Math.random() * (999999999 - 1)) + 1;

package/lib/generate-random-hash.js.map

@@ -1 +1 @@
-{"version":3,"file":"generate-random-hash.js","sourceRoot":"","sources":["../src/generate-random-hash.js"],"names":[],"mappings":"AAAA,OAAO,OAAO,MAAM,aAAa,CAAC;AAElC,MAAM,OAAO,GAAG,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC,EAAE,sCAAsC,CAAC,CAAC;AAEpF,eAAe,GAAG,EAAE;IAClB,MAAM,YAAY,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,CAAC,SAAS,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;IACrE,OAAO,OAAO,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;AACtC,CAAC,CAAC"}
+{"version":3,"file":"generate-random-hash.js","sourceRoot":"","sources":["../src/generate-random-hash.ts"],"names":[],"mappings":"AAAA,OAAO,OAAO,MAAM,SAAS,CAAC;AAE9B,MAAM,OAAO,GAAG,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC,EAAE,sCAAsC,CAAC,CAAC;AAEpF,eAAe,GAAG,EAAE;IAClB,MAAM,YAAY,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,CAAC,SAAS,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;IACrE,OAAO,OAAO,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;AACtC,CAAC,CAAC"}

package/lib/locale-helpers.d.ts

@@ -1,7 +1,8 @@
-export const systemLocale: any;
-export function resolveBestSupported(acceptLanguage: any, supportedLocales: any): any;
+export const systemLocale: localePkg.Locale;
+export function resolveBestSupported(acceptLanguage: any, supportedLocales: any): localePkg.Locale;
 export function resolveBestCountry(localeCountry: any, shopCountry: any, countries: any): any;
 export function resolveUserRemoteAddress(req: any): {
     remoteAddress: any;
     remotePort: any;
 };
+import localePkg from "locale";

package/lib/locale-helpers.js

@@ -1,4 +1,5 @@
-import { Locales, Locale } from 'locale';
+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) => {

package/lib/locale-helpers.js.map

@@ -1 +1 @@
-{"version":3,"file":"locale-helpers.js","sourceRoot":"","sources":["../src/locale-helpers.js"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEzC,MAAM,EAAE,cAAc,GAAG,IAAI,EAAE,iBAAiB,GAAG,IAAI,EAAE,GAAG,OAAO,CAAC,GAAG,CAAC;AAExE,MAAM,CAAC,MAAM,YAAY,GAAG,IAAI,MAAM,CAAC,GAAG,cAAc,IAAI,iBAAiB,EAAE,CAAC,CAAC;AAEjF,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,cAAc,EAAE,gBAAgB,EAAE,EAAE;IACvE,MAAM,YAAY,GAAG,IAAI,OAAO,CAAC,cAAc,CAAC,CAAC;IACjD,MAAM,UAAU,GAAG,YAAY,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;IACvD,IAAI,CAAC,UAAU;QAAE,OAAO,YAAY,CAAC;IACrC,OAAO,UAAU,CAAC;AACpB,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,aAAa,EAAE,WAAW,EAAE,SAAS,EAAE,EAAE;IAC1E,IAAI,WAAW,EAAE;QACf,MAAM,eAAe,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC,YAAY,EAAE,OAAO,EAAE,EAAE;YACjE,IAAI,WAAW,KAAK,OAAO,CAAC,OAAO,EAAE;gBACnC,OAAO,OAAO,CAAC,OAAO,CAAC;aACxB;YACD,OAAO,YAAY,CAAC;QACtB,CAAC,EAAE,IAAI,CAAC,CAAC;QACT,IAAI,eAAe,EAAE;YACnB,OAAO,eAAe,CAAC;SACxB;KACF;IACD,OAAO,aAAa,IAAI,YAAY,CAAC,OAAO,CAAC;AAC/C,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,wBAAwB,GAAG,CAAC,GAAG,EAAE,EAAE;IAC9C,MAAM,aAAa,GACjB,GAAG,CAAC,OAAO,CAAC,WAAW,CAAC;QACxB,GAAG,CAAC,OAAO,CAAC,iBAAiB,CAAC;QAC9B,GAAG,CAAC,UAAU,CAAC,aAAa;QAC5B,GAAG,CAAC,MAAM,CAAC,aAAa;QACxB,GAAG,CAAC,UAAU,CAAC,MAAM,CAAC,aAAa,CAAC;IAEtC,MAAM,UAAU,GACd,GAAG,CAAC,UAAU,EAAE,UAAU,IAAI,GAAG,CAAC,MAAM,EAAE,UAAU,IAAI,GAAG,CAAC,UAAU,EAAE,MAAM,EAAE,UAAU,CAAC;IAE7F,OAAO,EAAE,aAAa,EAAE,UAAU,EAAE,CAAC;AACvC,CAAC,CAAC"}
+{"version":3,"file":"locale-helpers.js","sourceRoot":"","sources":["../src/locale-helpers.js"],"names":[],"mappings":"AAAA,OAAO,SAAS,MAAM,QAAQ,CAAC;AAE/B,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC;AAEtC,MAAM,EAAE,cAAc,GAAG,IAAI,EAAE,iBAAiB,GAAG,IAAI,EAAE,GAAG,OAAO,CAAC,GAAG,CAAC;AAExE,MAAM,CAAC,MAAM,YAAY,GAAG,IAAI,MAAM,CAAC,GAAG,cAAc,IAAI,iBAAiB,EAAE,CAAC,CAAC;AAEjF,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,cAAc,EAAE,gBAAgB,EAAE,EAAE;IACvE,MAAM,YAAY,GAAG,IAAI,OAAO,CAAC,cAAc,CAAC,CAAC;IACjD,MAAM,UAAU,GAAG,YAAY,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;IACvD,IAAI,CAAC,UAAU;QAAE,OAAO,YAAY,CAAC;IACrC,OAAO,UAAU,CAAC;AACpB,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,aAAa,EAAE,WAAW,EAAE,SAAS,EAAE,EAAE;IAC1E,IAAI,WAAW,EAAE;QACf,MAAM,eAAe,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC,YAAY,EAAE,OAAO,EAAE,EAAE;YACjE,IAAI,WAAW,KAAK,OAAO,CAAC,OAAO,EAAE;gBACnC,OAAO,OAAO,CAAC,OAAO,CAAC;aACxB;YACD,OAAO,YAAY,CAAC;QACtB,CAAC,EAAE,IAAI,CAAC,CAAC;QACT,IAAI,eAAe,EAAE;YACnB,OAAO,eAAe,CAAC;SACxB;KACF;IACD,OAAO,aAAa,IAAI,YAAY,CAAC,OAAO,CAAC;AAC/C,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,wBAAwB,GAAG,CAAC,GAAG,EAAE,EAAE;IAC9C,MAAM,aAAa,GACjB,GAAG,CAAC,OAAO,CAAC,WAAW,CAAC;QACxB,GAAG,CAAC,OAAO,CAAC,iBAAiB,CAAC;QAC9B,GAAG,CAAC,UAAU,CAAC,aAAa;QAC5B,GAAG,CAAC,MAAM,CAAC,aAAa;QACxB,GAAG,CAAC,UAAU,CAAC,MAAM,CAAC,aAAa,CAAC;IAEtC,MAAM,UAAU,GACd,GAAG,CAAC,UAAU,EAAE,UAAU,IAAI,GAAG,CAAC,MAAM,EAAE,UAAU,IAAI,GAAG,CAAC,UAAU,EAAE,MAAM,EAAE,UAAU,CAAC;IAE7F,OAAO,EAAE,aAAa,EAAE,UAAU,EAAE,CAAC;AACvC,CAAC,CAAC"}

package/package.json

@@ -1,15 +1,19 @@
 {
   "name": "@unchainedshop/utils",
-  "version": "1.1.4",
+  "version": "1.2.0",
   "main": "lib/utils-index.js",
+  "exports": {
+    ".": "./lib/utils-index.js",
+    "./*": "./lib/*"
+  },
   "types": "lib/utils-index.d.ts",
   "type": "module",
   "scripts": {
+    "prepublishOnly": "npm install && npm run build || :",
     "clean": "rm -rf lib",
-    "build": "npm run clean && tsc -p tsconfig.build.json",
-    "watch": "tsc --watch",
-    "link:core": "npm link @unchainedshop/types && npm link @unchainedshop/logger",
-    "test": "METEOR_PACKAGE_DIRS=../ TEST_CLIENT=0 TEST_WATCH=1 meteor test-packages ./ --driver-package meteortesting:mocha --port 4200"
+    "build": "npm run clean && tsc",
+    "watch": "tsc -w",
+    "test": "jest --watch"
   },
   "repository": {
     "type": "git",
@@ -26,7 +30,7 @@
   },
   "homepage": "https://github.com/unchainedshop/unchained#readme",
   "dependencies": {
-    "@unchainedshop/logger": "1.1.3",
+    "@unchainedshop/logger": "^1.1.9",
     "abort-controller": "3.0.0",
     "bson": "^4.6.4",
     "hashids": "^2.2.10",
@@ -35,10 +39,8 @@
     "simpl-schema": "^1.12.2"
   },
   "devDependencies": {
-    "@types/mocha": "^9.1.1",
-    "@unchainedshop/types": "1.1.0",
-    "chai": "^4.3.6",
-    "mocha": "^10.0.0",
+    "@types/node": "^16.11.44",
+    "@unchainedshop/types": "^1.1.9",
     "typescript": "^4.7.4"
   }
 }

package/src/buildSortOption.ts

@@ -0,0 +1,16 @@
+import { SortOption } from '@unchainedshop/types/api';
+
+const SORT_DIRECTIONS = {
+  ASC: 1,
+  DESC: -1,
+};
+
+const buildSortOptions = (sort: Array<SortOption> = []): { [key: string]: [value: number] } => {
+  const sortBy = {};
+  sort?.forEach(({ key, value }) => {
+    sortBy[key] = SORT_DIRECTIONS[value];
+  });
+  return sortBy;
+};
+
+export default buildSortOptions;

package/src/db/build-db-indexes.ts

@@ -0,0 +1,35 @@
+import { Collection, Indexes, Document } from '@unchainedshop/types/common';
+import { log, LogLevel } from '@unchainedshop/logger';
+
+const buildIndexes = <T>(collection: Collection<T>, indexes: Indexes<T>): Promise<Array<void | Error>> =>
+  Promise.all(
+    indexes.map(async ({ index, options }) => {
+      await collection.createIndex(index, options).catch((error) => error as Error);
+    }),
+  );
+
+export const buildDbIndexes = async <T extends Document>(
+  collection: Collection<T>,
+  indexes: Indexes<T>,
+) => {
+  let success = true;
+  const buildErrors = (await buildIndexes<T>(collection, indexes)).filter(Boolean);
+
+  if (buildErrors.length) {
+    const dropError = await collection.dropIndexes().catch((e) => e);
+
+    if (!dropError) {
+      const rebuildErrors = (await buildIndexes<T>(collection, indexes)).filter(Boolean);
+
+      if (rebuildErrors.length) {
+        log('Error building indexes', {
+          level: LogLevel.Error,
+          ...rebuildErrors,
+        });
+        success = false;
+      }
+    }
+  }
+
+  return success;
+};

package/src/db/check-id.ts

@@ -0,0 +1,5 @@
+export const checkId = (value: string, error?: { message: string; path?: string }): void => {
+  if (typeof value !== 'string') {
+    throw error || { message: 'Invalid id' };
+  }
+};

package/src/db/generate-db-filter-by-id.ts

@@ -0,0 +1,9 @@
+import { Filter, Query, _ID } from '@unchainedshop/types/common';
+
+export const generateDbFilterById = (
+  id: unknown,
+  query: Query = {},
+): Filter<{ _id?: _ID; [x: string]: any }> => {
+  const _id = id || null; // never undefined, else it will get the first one
+  return { _id, ...query };
+};

package/src/db/generate-db-mutations.ts

@@ -0,0 +1,101 @@
+import SimpleSchema from 'simpl-schema';
+import {
+  Collection,
+  ModuleMutations,
+  ModuleCreateMutation,
+  _ID,
+  Update,
+  TimestampFields,
+} from '@unchainedshop/types/common';
+import { checkId } from './check-id';
+import { generateDbObjectId } from './generate-db-object-id';
+import { generateDbFilterById } from './generate-db-filter-by-id';
+
+export const generateDbMutations = <T extends TimestampFields & { _id?: _ID }>(
+  collection: Collection<T>,
+  schema: SimpleSchema,
+  options?: {
+    hasCreateOnly?: boolean;
+    permanentlyDeleteByDefault?: boolean;
+  },
+): ModuleMutations<T> | ModuleCreateMutation<T> => {
+  if (!collection) throw new Error('Collection is missing');
+  if (!schema) throw new Error('Schema is missing');
+
+  const { hasCreateOnly, permanentlyDeleteByDefault } = options || {
+    hasCreateOnly: false,
+    permanentlyDeleteByDefault: false,
+  };
+
+  const deletePermanently = async (_id) => {
+    checkId(_id);
+    const filter = generateDbFilterById(_id);
+    const result = await collection.deleteOne(filter);
+    return result.deletedCount;
+  };
+
+  return {
+    create: async (doc, userId) => {
+      const values = schema.clean(doc);
+      values.created = new Date();
+      values.createdBy = userId;
+      schema.validate(values);
+      values._id = doc._id || generateDbObjectId();
+
+      const result = await collection.insertOne(values);
+      return result.insertedId as string;
+    },
+
+    update: hasCreateOnly
+      ? undefined
+      : async (_id, doc, userId) => {
+          checkId(_id);
+
+          let modifier: Update<T>;
+
+          if ((doc as Update<T>)?.$set) {
+            const values = schema.clean(doc, { isModifier: true });
+            modifier = {
+              ...values,
+              $set: {
+                ...(values.$set || {}),
+                updated: new Date(),
+                updatedBy: userId,
+              },
+            };
+          } else {
+            const values = schema.clean(doc);
+            modifier = {
+              $set: {
+                ...values,
+                updated: new Date(),
+                updatedBy: userId,
+              },
+            };
+          }
+
+          schema.validate(modifier, { modifier: true });
+          const filter = generateDbFilterById(_id, { deleted: null });
+          await collection.updateOne(filter, modifier);
+
+          return _id;
+        },
+
+    deletePermanently: hasCreateOnly ? undefined : deletePermanently,
+
+    delete: hasCreateOnly
+      ? undefined
+      : async (_id, userId) => {
+          if (permanentlyDeleteByDefault) {
+            return deletePermanently(_id);
+          }
+          checkId(_id);
+          const filter = generateDbFilterById(_id, { deleted: null });
+          const modifier = { $set: { deleted: new Date(), deletedBy: userId } };
+          const values = schema.clean(modifier, { isModifier: true });
+          const result = await collection.updateOne(filter, values);
+
+          return result.modifiedCount;
+        },
+  };
+};

package/src/db/generate-db-object-id.ts

@@ -0,0 +1,25 @@
+import crypto from 'crypto';
+
+// Source: https://github.com/meteor/meteor/blob/devel/packages/random/NodeRandomGenerator.js
+/**
+ * @name Random.hexString
+ * @summary Return a random string of `n` hexadecimal digits.
+ * @locus Anywhere
+ * @param {Number} n Length of the string
+ */
+export const generateDbObjectId = (digits = 24): string => {
+  const numBytes = Math.ceil(digits / 2);
+  let bytes;
+  // Try to get cryptographically strong randomness. Fall back to
+  // non-cryptographically strong if not available.
+  try {
+    bytes = crypto.randomBytes(numBytes);
+  } catch (e) {
+    // XXX should re-throw any error except insufficient entropy
+    bytes = crypto.pseudoRandomBytes(numBytes);
+  }
+  const result = bytes.toString('hex');
+  // If the number of digits is odd, we'll have generated an extra 4 bits
+  // of randomness, so we need to trim the last digit.
+  return result.substring(0, digits);
+};

package/src/director/BaseAdapter.ts

@@ -0,0 +1,8 @@
+import { IBaseAdapter } from '@unchainedshop/types/common';
+import { log, LogLevel } from '@unchainedshop/logger';
+
+export const BaseAdapter: Omit<IBaseAdapter, 'key' | 'label' | 'version'> = {
+  log(message: string, { level = LogLevel.Debug, ...options } = {}) {
+    return log(message, { level, ...options });
+  },
+};

package/src/director/BaseDirector.ts

@@ -0,0 +1,36 @@
+import { IBaseAdapter, IBaseDirector } from '@unchainedshop/types/common';
+import { log } from '@unchainedshop/logger';
+
+export const BaseDirector = <AdapterType extends IBaseAdapter>(
+  directorName: string,
+  options?: {
+    adapterSortKey?: string;
+    adapterKeyField?: string; // Set to 'key' per default
+  },
+): IBaseDirector<AdapterType> => {
+  const Adapters = new Map<string, AdapterType>();
+  const keyField = options?.adapterKeyField || 'key';
+
+  return {
+    getAdapter: (key) => {
+      return Adapters.get(key);
+    },
+
+    getAdapters: ({ adapterFilter } = {}) => {
+      const sortKey = options?.adapterSortKey || keyField;
+      return Array.from(Adapters.values())
+        .sort((left, right) => left[sortKey] - right[sortKey])
+        .filter(adapterFilter || (() => true));
+    },
+
+    registerAdapter: (Adapter) => {
+      log(
+        `${directorName} -> Registered ${keyField !== 'key' ? `${Adapter[keyField]} ` : ' '} ${
+          Adapter.key
+        } ${Adapter.version} (${Adapter.label})`,
+      );
+
+      Adapters.set(Adapter[keyField], Adapter);
+    },
+  };
+};

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
+}

package/src/utils-index.js

@@ -0,0 +1,52 @@
+import { AddressSchema } from './schemas/AddressSchema';
+import { ContactSchema } from './schemas/ContactSchema';
+import { timestampFields, contextFields, logFields } from './schemas/commonSchemaFields';
+import { UserSchema } from './schemas/UsersSchema';
+
+export { default as findLocalizedText } from './find-localized-text';
+export * from './locale-helpers';
+export { default as objectInvert } from './object-invert';
+export { default as findUnusedSlug } from './find-unused-slug';
+export { default as slugify } from './slugify';
+export { default as pipePromises } from './pipe-promises';
+export { default as generateRandomHash } from './generate-random-hash';
+export { default as randomValueHex } from './random-value-hex';
+export { default as buildSortOptions } from './buildSortOption';
+
+/*
+ * Db utils
+ */
+
+export { checkId } from './db/check-id';
+export { generateDbObjectId } from './db/generate-db-object-id';
+export { generateDbFilterById } from './db/generate-db-filter-by-id';
+export { generateDbMutations } from './db/generate-db-mutations';
+export { buildDbIndexes } from './db/build-db-indexes';
+export { findPreservingIds } from './find-preserving-ids';
+
+/*
+ * Schemas
+ */
+
+const Schemas = {
+  timestampFields,
+  contextFields,
+  logFields,
+  Address: AddressSchema,
+  Contact: ContactSchema,
+  User: UserSchema,
+};
+
+export { Schemas };
+
+/*
+ * Director
+ */
+
+export { BaseAdapter } from './director/BaseAdapter';
+export { BaseDirector } from './director/BaseDirector';
+export { BasePricingAdapter } from './director/BasePricingAdapter';
+export { BasePricingDirector } from './director/BasePricingDirector';
+export { BasePricingSheet } from './director/BasePricingSheet';
+export { BaseDiscountAdapter } from './director/BaseDiscountAdapter';
+export { BaseDiscountDirector } from './director/BaseDiscountDirector';

package/tsconfig.json

@@ -1,8 +1,29 @@
 {
-  "extends": "./tsconfig.build.json",
   "compilerOptions": {
-    "noEmit": true,
-    "types": ["node", "mocha"],
+    "allowJs": true,
+    "allowSyntheticDefaultImports": true,
+    "declaration": true,
+    "esModuleInterop": true,
+    "experimentalDecorators": true,
+    "forceConsistentCasingInFileNames": true,
+    "lib": [
+      "esnext"
+    ],
+    "module": "esnext",
+    "moduleResolution": "node",
+    "noImplicitReturns": true,
+    "noUnusedLocals": false,
+    "outDir": "lib",
+    "preserveWatchOutput": true,
+    "skipLibCheck": true,
+    "sourceMap": true,
+    "target": "esnext",
+    "types": [
+      "node",
+      "jest"
+    ]
   },
-  "include": ["src", "tests"]
-}
+  "include": [
+    "src"
+  ]
+}

package/tsconfig.build.json

@@ -1,26 +0,0 @@
-{
-  "compilerOptions": {
-    "allowJs": true,
-    "allowSyntheticDefaultImports": true,
-    "declaration": true,
-    "esModuleInterop": true,
-    "experimentalDecorators": true,
-    "forceConsistentCasingInFileNames": true,
-    "lib": ["esnext"],
-    "module": "esnext",
-    "moduleResolution": "node",
-    "noImplicitReturns": true,
-    "noUnusedLocals": false,
-    "outDir": "lib",
-    "preserveWatchOutput": true,
-    "skipLibCheck": true,
-    "sourceMap": true,
-    "target": "esnext",
-    "types": ["node"],
-    "baseUrl": ".", // This must be specified if "paths" is.
-    "paths": {
-      "meteor/unchained:*": ["node_modules/@unchainedshop/types/index.d.ts"]
-    }
-  },
-  "include": ["src"]
-}