@unchainedshop/platform 1.1.3

package/lib/templates/utils/getOrderPositionsData.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getOrderPositionsData.js","sourceRoot":"","sources":["../../../src/templates/utils/getOrderPositionsData.ts"],"names":[],"mappings":"AAIA,MAAM,CAAC,MAAM,qBAAqB,GAAG,KAAK,EACxC,KAAY,EACZ,MAA2B,EAC3B,OAAgB,EAChB,EAAE;IACF,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC;IAC5B,MAAM,cAAc,GAAG,MAAM,OAAO,CAAC,MAAM,CAAC,SAAS,CAAC,kBAAkB,CAAC;QACvE,OAAO,EAAE,KAAK,CAAC,GAAG;KACnB,CAAC,CAAC;IAEH,MAAM,WAAW,GAAG,CAAC,KAAa,EAAE,EAAE;QACpC,MAAM,UAAU,GAAG,KAAK,GAAG,GAAG,CAAC;QAC/B,OAAO,GAAG,KAAK,CAAC,QAAQ,IAAI,UAAU,EAAE,CAAC;IAC3C,CAAC,CAAC;IAEF,MAAM,OAAO,CAAC,GAAG,CACf,cAAc,CAAC,GAAG,CAAC,KAAK,EAAE,aAAa,EAAE,EAAE;QACzC,MAAM,YAAY,GAAG,MAAM,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,iBAAiB,CAAC;YAClE,SAAS,EAAE,aAAa,CAAC,SAAS;YAClC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU;SAClC,CAAC,CAAC;QACH,MAAM,oBAAoB,GAAG,MAAM,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,iBAAiB,CAAC;YAC1E,SAAS,EAAE,aAAa,CAAC,iBAAiB;YAC1C,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU;SAClC,CAAC,CAAC;QAEH,MAAM,YAAY,GAAG,YAAY,EAAE,KAAK,CAAC,CAAC,aAAa;QAEvD,MAAM,eAAe,GAAG,OAAO,CAAC,MAAM,CAAC,SAAS,CAAC,YAAY,CAC3D,aAAa,EACb,KAAK,CAAC,QAAQ,EACd,OAAO,CACR,CAAC;QACF,MAAM,KAAK,GAAG,WAAW,CAAC,eAAe,CAAC,GAAG,EAAE,CAAC,CAAC;QACjD,MAAM,EAAE,QAAQ,EAAE,GAAG,eAAe,CAAC;QACrC,OAAO;YACL,oBAAoB;YACpB,OAAO,EAAE,YAAY;YACrB,YAAY;YACZ,QAAQ;YACR,KAAK;SACN,CAAC;IACJ,CAAC,CAAC,CACH,CAAC;AACJ,CAAC,CAAC"}

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@unchainedshop/platform",
+  "version": "1.1.3",
+  "main": "lib/platform-index.js",
+  "types": "lib/platform-index.d.ts",
+  "type": "module",
+  "scripts": {
+    "clean": "rm -rf lib",
+    "build": "npm run clean && tsc -p tsconfig.build.json",
+    "watch": "tsc --watch",
+    "link:core": "npm link  @unchainedshop/types",
+    "test": "cross-env METEOR_PACKAGE_DIRS=../ TEST_CLIENT=0 TEST_WATCH=1 meteor test-packages ./ --driver-package meteortesting:mocha --port 4200"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/unchainedshop/unchained.git"
+  },
+  "keywords": [
+    "unchained",
+    "ecommerce",
+    "core"
+  ],
+  "author": "Joël Meiller",
+  "license": "EUPL-1.2",
+  "bugs": {
+    "url": "https://github.com/unchainedshop/unchained/issues"
+  },
+  "homepage": "https://github.com/unchainedshop/unchained#readme",
+  "dependencies": {
+    "JSONStream": "^1.3.5",
+    "event-iterator": "^2.0.0",
+    "moniker": "0.1.2",
+    "open": "^8.4.0",
+    "@unchainedshop/events": "1.1.x",
+    "@unchainedshop/file-upload": "1.1.x",
+    "@unchainedshop/logger": "1.1.x",
+    "@unchainedshop/mongodb": "1.1.x",
+    "@unchainedshop/roles": "1.1.x",
+    "@unchainedshop/utils": "1.1.x"
+  },
+  "peerDependencies": {
+    "@unchainedshop/api": "1.1.x",
+    "@unchainedshop/core": "1.1.x",
+    "@unchainedshop/plugins": "1.1.x"
+  },
+  "devDependencies": {
+    "@types/chai": "^4.3.1",
+    "@types/mocha": "^9.1.1",
+    "@types/moment": "^2.13.0",
+    "@unchainedshop/api": "1.1.x",
+    "@unchainedshop/core": "1.1.x",
+    "@unchainedshop/plugins": "1.1.x",
+    "@unchainedshop/types": "1.1.x",
+    "chai": "^4.3.6",
+    "cross-env": "^7.0.3",
+    "typescript": "^4.7.4"
+  }
+}

package/src/bulk-importer/createBulkImporter.ts

@@ -0,0 +1,120 @@
+import mongodb from 'mongodb';
+import { BulkImportHandler, BulkImportOperation } from '@unchainedshop/types/platform';
+import { BulkImporter } from '@unchainedshop/types/core';
+import * as AssortmentHandlers from './handlers/assortment';
+import * as FilterHandlers from './handlers/filter';
+import * as ProductHandlers from './handlers/product';
+
+let bulkOperationHandlers: Record<string, BulkImportHandler> = {};
+
+export const getOperation = (entity: string, operation: string): BulkImportOperation => {
+  const handlers = bulkOperationHandlers[entity];
+  if (!handlers) {
+    throw new Error(`Entity ${entity} unknown`);
+  }
+
+  const entityOperation = handlers[operation] as BulkImportOperation;
+
+  if (!entityOperation || typeof entityOperation !== 'function') {
+    throw new Error(`Operation ${operation} for entity ${entity} invalid`);
+  }
+
+  return entityOperation;
+};
+
+export const createBulkImporterFactory = (db, additionalHandlers): BulkImporter => {
+  // Increase the chunk size to 5MB to get around chunk sorting limits of mongodb (weird error above 100 MB)
+  const BulkImportPayloads = new mongodb.GridFSBucket(db, {
+    bucketName: 'bulk_import_payloads',
+    chunkSizeBytes: 5 * 1024 * 1024,
+  });
+
+  bulkOperationHandlers = {
+    ASSORTMENT: AssortmentHandlers as BulkImportHandler,
+    PRODUCT: ProductHandlers,
+    FILTER: FilterHandlers,
+    ...additionalHandlers,
+  };
+
+  const createBulkImporter: BulkImporter['createBulkImporter'] = (options, requestContext) => {
+    const bulkOperations = {};
+    const preparationIssues = [];
+    const processedOperations = {};
+    const { logger, createShouldUpsertIfIDExists, skipCacheInvalidation } = options;
+
+    const bulk = (collectionName: string) => {
+      const Collection = db.collection(collectionName);
+      bulkOperations[collectionName] = Collection.initializeOrderedBulkOp();
+      return bulkOperations[collectionName];
+    };
+
+    logger.info(
+      `Configure event import with options: createShouldUpsertIfIDExists=${createShouldUpsertIfIDExists} skipCacheInvalidation=${skipCacheInvalidation}`,
+    );
+
+    return {
+      prepare: async (event) => {
+        const entity = event.entity.toUpperCase();
+        const operation = event.operation.toLowerCase();
+
+        const handler = getOperation(entity, operation);
+
+        const payloadId = event.payload?._id || 'global';
+
+        logger.verbose(`${operation} ${entity} ${payloadId} [PREPARE]`);
+        logger.profile(`${operation} ${entity} ${payloadId} [DONE]`, {
+          level: 'verbose',
+        });
+
+        try {
+          await handler(event.payload, { bulk, ...options }, requestContext);
+          if (!processedOperations[entity]) processedOperations[entity] = {};
+          if (!processedOperations[entity][operation]) processedOperations[entity][operation] = [];
+          processedOperations[entity][operation].push(payloadId);
+          logger.verbose(`${operation} ${entity} ${payloadId} [SUCCESS]`);
+        } catch (e) {
+          logger.verbose(`${operation} ${entity} ${payloadId} [FAILED]: ${e.message}`);
+          preparationIssues.push({
+            operation,
+            entity,
+            payloadId,
+            errorCode: e.name,
+            errorMessage: e.message,
+          });
+        } finally {
+          logger.profile(`${operation} ${entity} ${payloadId} [DONE]`, {
+            level: 'verbose',
+          });
+        }
+      },
+      execute: async () => {
+        logger.info(`Execute bulk operations for: ${Object.keys(bulkOperations).join(', ')}`);
+        const operationResults = {
+          processedOperations,
+          processedBulkOperations: (
+            await Promise.all(Object.values(bulkOperations).map((o: any) => o.execute()))
+          ).map((r) => r.result),
+        };
+        if (preparationIssues?.length) {
+          logger.error(
+            `${preparationIssues.length} issues occured while preparing events, import finished with errors`,
+          );
+          const errors = { preparationIssues };
+          return [operationResults, errors];
+        }
+        logger.info(`Import finished without errors`);
+        return [operationResults, null];
+      },
+      invalidateCaches: async () => {
+        if (skipCacheInvalidation) return;
+        await requestContext.modules.assortments.invalidateCache({});
+        await requestContext.modules.filters.invalidateCache({}, requestContext);
+      },
+    };
+  };
+
+  return {
+    BulkImportPayloads,
+    createBulkImporter,
+  };
+};

package/src/bulk-importer/handlers/assortment/create.ts

@@ -0,0 +1,86 @@
+import { Context } from '@unchainedshop/types/api';
+import upsertAssortmentChildren from './upsertAssortmentChildren';
+import upsertAssortmentContent from './upsertAssortmentContent';
+import upsertAssortmentFilters from './upsertAssortmentFilters';
+import upsertAssortmentProducts from './upsertAssortmentProducts';
+import upsertMedia from './upsertMedia';
+
+export default async function createAssortment(
+  payload: any,
+  { logger, authorId, createShouldUpsertIfIDExists },
+  unchainedAPI: Context,
+) {
+  const { modules, userId } = unchainedAPI;
+  const { media, specification, products, children, filters, _id } = payload;
+
+  if (!specification) throw new Error(`Specification is required when creating new assortment ${_id}`);
+
+  if (!specification.content)
+    throw new Error(`Assortment content is required when creating new assortment${_id}`);
+
+  logger.debug('create assortment object', specification);
+  try {
+    await modules.assortments.create({ ...specification, _id, authorId }, userId);
+  } catch (e) {
+    if (!createShouldUpsertIfIDExists) throw e;
+    logger.debug('entity already exists, falling back to update', specification);
+    await modules.assortments.update(
+      _id,
+      {
+        ...specification,
+        authorId,
+      },
+      userId,
+    );
+  }
+
+  logger.debug('create localized content for assortment', specification.content);
+  await upsertAssortmentContent(
+    {
+      content: specification.content,
+      assortmentId: _id,
+      authorId,
+    },
+    unchainedAPI,
+  );
+
+  logger.debug('create product products', products);
+  await upsertAssortmentProducts(
+    {
+      products: products || [],
+      assortmentId: _id,
+      authorId,
+    },
+    unchainedAPI,
+  );
+
+  logger.debug('create assortment children', products);
+  await upsertAssortmentChildren(
+    {
+      children: children || [],
+      assortmentId: _id,
+      authorId,
+    },
+    unchainedAPI,
+  );
+
+  logger.debug('create assortment filters', products);
+  await upsertAssortmentFilters(
+    {
+      filters: filters || [],
+      assortmentId: _id,
+      authorId,
+    },
+    unchainedAPI,
+  );
+
+  logger.debug('create assortment media', media);
+  await upsertMedia({ media: media || [], assortmentId: _id, authorId }, unchainedAPI);
+
+  return {
+    entity: 'ASSORTMENT',
+    operation: 'create',
+    _id,
+    success: true,
+  };
+}

package/src/bulk-importer/handlers/assortment/index.js

@@ -0,0 +1,3 @@
+export { default as create } from './create';
+export { default as update } from './update';
+export { default as remove } from './remove';

package/src/bulk-importer/handlers/assortment/remove.ts

@@ -0,0 +1,15 @@
+import { Context } from '@unchainedshop/types/api';
+
+export default async function removeAssortment(payload, { logger }, unchainedAPI: Context) {
+  const { modules, userId } = unchainedAPI;
+  const { _id } = payload;
+  logger.debug('remove assortment');
+  await modules.assortments.delete(_id, { skipInvalidation: true }, userId);
+
+  return {
+    entity: 'ASSORTMENT',
+    operation: 'remove',
+    _id,
+    success: true,
+  };
+}

package/src/bulk-importer/handlers/assortment/update.ts

@@ -0,0 +1,85 @@
+import { Context } from '@unchainedshop/types/api';
+import upsertAssortmentContent from './upsertAssortmentContent';
+import upsertAssortmentProducts from './upsertAssortmentProducts';
+import upsertAssortmentChildren from './upsertAssortmentChildren';
+import upsertAssortmentFilters from './upsertAssortmentFilters';
+import upsertMedia from './upsertMedia';
+
+export default async function updateAssortment(
+  payload: any,
+  { logger, authorId },
+  unchainedAPI: Context,
+) {
+  const { modules, userId } = unchainedAPI;
+  const { media, specification, products, children, filters, _id } = payload;
+
+  if (specification) {
+    logger.debug('update assortment object', specification);
+    await unchainedAPI.modules.assortments.update(_id, { ...specification, authorId }, userId);
+
+    if (specification.content) {
+      logger.debug('replace localized content for assortment', specification.content);
+      await upsertAssortmentContent(
+        {
+          content: specification.content,
+          assortmentId: _id,
+          authorId,
+        },
+        unchainedAPI,
+      );
+    }
+  }
+
+  if (products || children || filters || media) {
+    if (!(await modules.assortments.assortmentExists({ assortmentId: _id }))) {
+      throw new Error(`Can't update non-existing assortment ${_id}`);
+    }
+  }
+
+  if (products) {
+    logger.debug('update product products', products);
+    await upsertAssortmentProducts(
+      {
+        products: products || [],
+        assortmentId: _id,
+        authorId,
+      },
+      unchainedAPI,
+    );
+  }
+
+  if (children) {
+    logger.debug('update assortment children', children);
+    await upsertAssortmentChildren(
+      {
+        children: children || [],
+        assortmentId: _id,
+        authorId,
+      },
+      unchainedAPI,
+    );
+  }
+
+  if (filters) {
+    logger.debug('update assortment filters', filters);
+    await upsertAssortmentFilters(
+      {
+        filters: filters || [],
+        assortmentId: _id,
+        authorId,
+      },
+      unchainedAPI,
+    );
+  }
+  if (media) {
+    logger.debug('update assortment media', media);
+    await upsertMedia({ media: media || [], assortmentId: _id, authorId }, unchainedAPI);
+  }
+
+  return {
+    entity: 'ASSORTMENT',
+    operation: 'update',
+    _id,
+    success: true,
+  };
+}

package/src/bulk-importer/handlers/assortment/upsertAssortmentChildren.ts

@@ -0,0 +1,51 @@
+import { Context } from '@unchainedshop/types/api';
+import { AssortmentLink } from '@unchainedshop/types/assortments';
+
+const upsert = async (assortmentLink: AssortmentLink, { modules, userId }: Context) => {
+  if (
+    !(await modules.assortments.assortmentExists({
+      assortmentId: assortmentLink.childAssortmentId,
+    }))
+  ) {
+    throw new Error(`Can't link non-existing assortment ${assortmentLink.childAssortmentId}`);
+  }
+  try {
+    return modules.assortments.links.create(assortmentLink, { skipInvalidation: true }, userId);
+  } catch (e) {
+    return modules.assortments.links.update(
+      assortmentLink._id,
+      assortmentLink,
+      { skipInvalidation: true },
+      userId,
+    );
+  }
+};
+
+export default async (
+  { children, authorId, assortmentId: parentAssortmentId },
+  unchainedAPI: Context,
+) => {
+  const { modules, userId } = unchainedAPI;
+  const assortmentLinkIds = await Promise.all(
+    children.map(async ({ assortmentId: childAssortmentId, ...childrenRest }) => {
+      const assortmentLink = await upsert(
+        {
+          ...childrenRest,
+          authorId,
+          parentAssortmentId,
+          childAssortmentId,
+        } as AssortmentLink,
+        unchainedAPI,
+      );
+      return assortmentLink._id;
+    }),
+  );
+  await modules.assortments.links.deleteMany(
+    {
+      _id: { $nin: assortmentLinkIds },
+      parentAssortmentId,
+    },
+    { skipInvalidation: true },
+    userId,
+  );
+};

package/src/bulk-importer/handlers/assortment/upsertAssortmentContent.ts

@@ -0,0 +1,20 @@
+import { Context } from '@unchainedshop/types/api';
+import { AssortmentText } from '@unchainedshop/types/assortments';
+
+export default async ({ assortmentId, content, authorId }, { modules, userId }: Context) => {
+  const assortment = await modules.assortments.findAssortment({ assortmentId });
+  if (!assortment) throw new Error(`Can't update content of non-existing assortment ${assortmentId}`);
+
+  await Promise.all(
+    Object.entries(content).map(
+      async ([locale, { authorId: tAuthorId, ...localizedData }]: [string, AssortmentText]) => {
+        return modules.assortments.texts.upsertLocalizedText(
+          assortmentId,
+          locale,
+          localizedData,
+          tAuthorId || authorId || userId,
+        );
+      },
+    ),
+  );
+};

package/src/bulk-importer/handlers/assortment/upsertAssortmentFilters.ts

@@ -0,0 +1,39 @@
+import { Context } from '@unchainedshop/types/api';
+import { AssortmentFilter } from '@unchainedshop/types/assortments';
+
+const upsert = async (assortmentFilter: AssortmentFilter, { modules, userId }: Context) => {
+  if (
+    !(await modules.filters.filterExists({
+      filterId: assortmentFilter.filterId,
+    }))
+  ) {
+    throw new Error(`Can't link non-existing filter ${assortmentFilter.filterId}`);
+  }
+  try {
+    return modules.assortments.filters.create(assortmentFilter, userId);
+  } catch (e) {
+    return modules.assortments.filters.update(assortmentFilter._id, assortmentFilter);
+  }
+};
+
+export default async ({ filters, authorId, assortmentId }, unchainedAPI: Context) => {
+  const { modules } = unchainedAPI;
+  const assortmentFilterIds = await Promise.all(
+    filters.map(async (filter: AssortmentFilter) => {
+      const assortmentFilter = await upsert(
+        {
+          ...filter,
+          authorId,
+          assortmentId,
+        },
+        unchainedAPI,
+      );
+      return assortmentFilter._id;
+    }),
+  );
+
+  await modules.assortments.filters.deleteMany({
+    _id: { $nin: assortmentFilterIds },
+    assortmentId,
+  });
+};

package/src/bulk-importer/handlers/assortment/upsertAssortmentProducts.ts

@@ -0,0 +1,55 @@
+import { Context } from '@unchainedshop/types/api';
+import { AssortmentProduct } from '@unchainedshop/types/assortments';
+
+const upsert = async (assortmentProduct: AssortmentProduct, unchainedAPI: Context) => {
+  const { modules, userId } = unchainedAPI;
+  if (
+    !(await modules.products.productExists({
+      productId: assortmentProduct.productId,
+    }))
+  ) {
+    throw new Error(`Can't link non-existing product ${assortmentProduct.productId}`);
+  }
+  try {
+    return modules.assortments.products.create(
+      assortmentProduct,
+      {
+        skipInvalidation: true,
+      },
+      userId,
+    );
+  } catch (e) {
+    return modules.assortments.products.update(
+      assortmentProduct._id,
+      assortmentProduct,
+      { skipInvalidation: true },
+      userId,
+    );
+  }
+};
+
+export default async ({ products, authorId, assortmentId }, unchainedAPI: Context) => {
+  const { modules, userId } = unchainedAPI;
+  const assortmentProductIds = await Promise.all(
+    products.map(async (product: AssortmentProduct) => {
+      const assortmentProduct = await upsert(
+        {
+          ...product,
+          authorId,
+          assortmentId,
+        },
+        unchainedAPI,
+      );
+      return assortmentProduct._id;
+    }),
+  );
+
+  await modules.assortments.products.deleteMany(
+    {
+      _id: { $nin: assortmentProductIds },
+      assortmentId,
+    },
+    { skipInvalidation: true },
+    userId,
+  );
+};

package/src/bulk-importer/handlers/assortment/upsertMedia.ts

@@ -0,0 +1,99 @@
+import { Context } from '@unchainedshop/types/api';
+import { AssortmentMediaText } from '@unchainedshop/types/assortments.media';
+import { File } from '@unchainedshop/types/files';
+
+const upsertAsset = async (
+  asset: File & { fileName: string; headers?: Record<string, unknown> },
+  unchainedAPI: Context,
+) => {
+  const { modules, services, userId } = unchainedAPI;
+  const { _id, fileName, url, meta, headers, ...assetData } = asset;
+  const fileId = _id;
+
+  try {
+    if (_id && (await modules.files.findFile({ fileId }))) throw new Error('Media already exists');
+
+    const assetObject = await services.files.uploadFileFromURL(
+      {
+        directoryName: 'assortment-media',
+        fileInput: {
+          fileLink: url,
+          fileName,
+          headers,
+        },
+        meta: { ...meta, fileId },
+        userId,
+      },
+      unchainedAPI,
+    );
+
+    if (!assetObject) throw new Error('Media not created');
+    return assetObject;
+  } catch (e) {
+    if (fileId) {
+      await modules.files.update(fileId, { meta: { ...meta, fileId }, ...assetData }, userId);
+      const file = await modules.files.findFile({ fileId });
+      return file;
+    }
+    return null;
+  }
+};
+
+const upsertMediaObject = async (media, unchainedAPI: Context) => {
+  const { modules, userId } = unchainedAPI;
+  try {
+    return modules.assortments.media.create(media, userId);
+  } catch (e) {
+    const { _id, ...mediaData } = media;
+    return modules.assortments.media.update(_id, mediaData);
+  }
+};
+
+export default async ({ media, authorId, assortmentId }, unchainedAPI: Context) => {
+  const { modules, userId } = unchainedAPI;
+  const mediaObjects = await Promise.all(
+    media.map(async ({ asset, content, ...mediaData }) => {
+      const file = await upsertAsset(
+        { meta: { ...(asset.meta || {}), assortmentId }, ...asset },
+        unchainedAPI,
+      );
+      if (!file) throw new Error(`Unable to create binary ${asset._id}`);
+
+      const mediaObject = await upsertMediaObject(
+        {
+          authorId,
+          ...mediaData,
+          assortmentId,
+          mediaId: file._id,
+        },
+        unchainedAPI,
+      );
+
+      if (!mediaObject) throw new Error(`Unable to create media object ${mediaObject._id}`);
+
+      if (content) {
+        await Promise.all(
+          Object.entries(content).map(
+            async ([locale, { authorId: tAuthorId, ...localizedData }]: [
+              string,
+              AssortmentMediaText,
+            ]) => {
+              return modules.assortments.media.texts.upsertLocalizedText(
+                mediaObject._id,
+                locale,
+                localizedData,
+                tAuthorId || authorId || userId,
+              );
+            },
+          ),
+        );
+      }
+      return mediaObject;
+    }),
+  );
+
+  await modules.assortments.media.deleteMediaFiles({
+    assortmentId,
+    excludedAssortmentMediaIds: mediaObjects.map((obj) => obj._id),
+  });
+};