@unchainedshop/platform 1.1.3

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

@@ -0,0 +1,62 @@
+import { Context } from '@unchainedshop/types/api';
+import upsertFilterContent from './upsertFilterContent';
+import upsertFilterOptionContent from './upsertFilterOptionContent';
+
+export default async function createFilter(
+  payload: any,
+  { logger, authorId, createShouldUpsertIfIDExists },
+  unchainedAPI: Context,
+) {
+  const { modules } = unchainedAPI;
+  const { specification, _id } = payload;
+
+  if (!specification) throw new Error(`Specification is required when creating new filter ${_id}`);
+
+  const { content, options, ...filterData } = specification;
+
+  if (!content) throw new Error(`Localizable content is required when creating new filter${_id}`);
+
+  logger.debug('create filter object', specification);
+  let filter;
+  try {
+    filter = await unchainedAPI.modules.filters.create(
+      {
+        ...filterData,
+        _id,
+        options: options?.map((option) => option.value) || [],
+        authorId,
+      },
+      unchainedAPI,
+      { skipInvalidation: true },
+      unchainedAPI.userId,
+    );
+  } catch (e) {
+    if (!createShouldUpsertIfIDExists) throw e;
+
+    logger.debug('entity already exists, falling back to update', specification);
+    filter = await modules.filters.update(
+      _id,
+      {
+        ...filterData,
+        options: options?.map((option) => option.value) || [],
+        authorId,
+      },
+      unchainedAPI,
+      { skipInvalidation: true },
+      unchainedAPI.userId,
+    );
+  }
+
+  logger.debug('create localized content for filter', content);
+  await upsertFilterContent({ content, filter, authorId }, unchainedAPI);
+
+  logger.debug('create localized content for filter options', content);
+  await upsertFilterOptionContent({ options, filter }, unchainedAPI);
+
+  return {
+    entity: 'FILTER',
+    operation: 'create',
+    _id,
+    success: true,
+  };
+}

package/src/bulk-importer/handlers/filter/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/filter/remove.ts

@@ -0,0 +1,16 @@
+import { Context } from '@unchainedshop/types/api';
+
+export default async function removeFilter(payload: any, { logger }, unchainedAPI: Context) {
+  const { modules, userId } = unchainedAPI;
+  const { _id } = payload;
+  logger.debug('remove filter');
+  await modules.assortments.filters.deleteMany({ filterId: _id }, userId);
+  await modules.filters.delete(_id);
+
+  return {
+    entity: 'FILTER',
+    operation: 'remove',
+    _id,
+    success: true,
+  };
+}

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

@@ -0,0 +1,49 @@
+import { Context } from '@unchainedshop/types/api';
+import upsertFilterContent from './upsertFilterContent';
+import upsertFilterOptionContent from './upsertFilterOptionContent';
+
+export default async function updateFilter(
+  payload: any,
+  { authorId, logger }: { authorId: string; logger: any },
+  unchainedAPI: Context,
+) {
+  const { modules } = unchainedAPI;
+  const { specification, _id } = payload;
+
+  if (!specification) throw new Error('Specification is required when creating a new filter');
+
+  logger.debug('update filter object', specification);
+  const { content, options, ...filterData } = specification;
+  const filter = await modules.filters.update(
+    _id,
+    {
+      ...filterData,
+      options: options?.map((option) => option.value) || [],
+      authorId,
+    },
+    unchainedAPI,
+    { skipInvalidation: true },
+    unchainedAPI.userId,
+  );
+
+  if (content || options) {
+    if (!filter) throw new Error(`Can't update non-existing filter ${_id}`);
+  }
+
+  if (content) {
+    logger.debug('replace localized content for filter', content);
+    await upsertFilterContent({ content, filter, authorId }, unchainedAPI);
+  }
+
+  if (options) {
+    logger.debug('replace localized content for filter options', content);
+    await upsertFilterOptionContent({ options, filter }, unchainedAPI);
+  }
+
+  return {
+    entity: 'FILTER',
+    operation: 'update',
+    _id,
+    success: true,
+  };
+}

package/src/bulk-importer/handlers/filter/upsertFilterContent.ts

@@ -0,0 +1,17 @@
+import { Context } from '@unchainedshop/types/api';
+import { FilterText } from '@unchainedshop/types/filters';
+
+export default async function upsertFilterContent({ content, filter, authorId }, unchainedAPI: Context) {
+  return Promise.all(
+    Object.entries(content).map(
+      async ([locale, { authorId: tAuthorId, ...localizedData }]: [string, FilterText]) => {
+        return unchainedAPI.modules.filters.texts.upsertLocalizedText(
+          { filterId: filter._id },
+          locale,
+          localizedData,
+          tAuthorId || authorId || unchainedAPI.userId,
+        );
+      },
+    ),
+  );
+}

package/src/bulk-importer/handlers/filter/upsertFilterOptionContent.ts

@@ -0,0 +1,21 @@
+import { Context } from '@unchainedshop/types/api';
+import { FilterText } from '@unchainedshop/types/filters';
+
+export default async function upsertFilterOptionContent({ options, filter }, unchainedAPI: Context) {
+  return Promise.all(
+    (options || []).map(async ({ content: optionContent, value: optionValue }) => {
+      await Promise.all(
+        Object.entries(optionContent).map(
+          async ([locale, { authorId, ...localizedData }]: [string, FilterText]) => {
+            return unchainedAPI.modules.filters.texts.upsertLocalizedText(
+              { filterId: filter._id, filterOptionValue: optionValue },
+              locale,
+              localizedData,
+              authorId || unchainedAPI.userId,
+            );
+          },
+        ),
+      );
+    }),
+  );
+}

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

@@ -0,0 +1,73 @@
+import { Context } from '@unchainedshop/types/api';
+import upsertVariations from './upsertVariations';
+import upsertMedia from './upsertMedia';
+import upsertProductContent from './upsertProductContent';
+import transformSpecificationToProductStructure from './transformSpecificationToProductStructure';
+
+export default async function createProduct(
+  payload: any,
+  { logger, authorId, createShouldUpsertIfIDExists },
+  unchainedAPI: Context,
+) {
+  const { modules, userId } = unchainedAPI;
+  const { specification, media, variations, _id } = payload;
+
+  if (!specification) throw new Error(`Specification is required when creating new product ${_id}`);
+
+  if (!specification.content) throw new Error(`Content is required when creating new product ${_id}`);
+
+  const productData = transformSpecificationToProductStructure(specification);
+  logger.debug('create product object', productData);
+  try {
+    await modules.products.create(
+      {
+        ...productData,
+        _id,
+        authorId,
+      },
+      userId,
+    );
+  } catch (e) {
+    if (!createShouldUpsertIfIDExists) throw e;
+
+    logger.debug('entity already exists, falling back to update', specification);
+    await modules.products.update(
+      _id,
+      {
+        ...productData,
+        authorId,
+      },
+      userId,
+    );
+  }
+
+  logger.debug('create localized content for product', specification.content);
+  await upsertProductContent(
+    {
+      content: specification.content,
+      productId: _id,
+      authorId,
+    },
+    unchainedAPI,
+  );
+
+  logger.debug('create product variations', variations);
+  await upsertVariations(
+    {
+      variations: variations || [],
+      productId: _id,
+      authorId,
+    },
+    unchainedAPI,
+  );
+
+  logger.debug('create product media', media);
+  await upsertMedia({ media: media || [], productId: _id, authorId }, unchainedAPI);
+
+  return {
+    entity: 'PRODUCT',
+    operation: 'create',
+    _id,
+    success: true,
+  };
+}

package/src/bulk-importer/handlers/product/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/product/remove.ts

@@ -0,0 +1,17 @@
+import { Context } from '@unchainedshop/types/api';
+
+export default async function removeProduct(payload: any, { logger }, unchainedAPI: Context) {
+  const { modules, userId } = unchainedAPI;
+  const { _id } = payload;
+  logger.debug('remove product');
+
+  // Use service services.product.removeProduct
+  await modules.products.delete(_id, userId);
+
+  return {
+    entity: 'PRODUCT',
+    operation: 'remove',
+    _id,
+    success: true,
+  };
+}

package/src/bulk-importer/handlers/product/transformSpecificationToProductStructure.js

@@ -0,0 +1,19 @@
+export default (specification) => {
+  const {
+    variationResolvers: assignments,
+    content, // eslint-disable-line
+    warehousing: warehousingEmbeddedSupply,
+    ...productData
+  } = specification;
+
+  const { dimensions: supply, ...warehousing } = warehousingEmbeddedSupply || {};
+
+  const proxy = assignments ? { assignments } : undefined;
+
+  return {
+    ...productData,
+    warehousing,
+    supply,
+    proxy,
+  };
+};

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

@@ -0,0 +1,65 @@
+import { Context } from '@unchainedshop/types/api';
+import upsertVariations from './upsertVariations';
+import upsertMedia from './upsertMedia';
+import upsertProductContent from './upsertProductContent';
+import transformSpecificationToProductStructure from './transformSpecificationToProductStructure';
+
+export default async function createProduct(payload: any, { logger, authorId }, unchainedAPI: Context) {
+  const { modules, userId } = unchainedAPI;
+  const { specification, media, variations, _id } = payload;
+
+  if (specification) {
+    const productData = transformSpecificationToProductStructure(specification);
+    logger.debug('update product object', productData);
+    await modules.products.update(
+      _id,
+      {
+        ...productData,
+        authorId,
+      },
+      userId,
+    );
+
+    if (specification.content) {
+      logger.debug('replace localized content for product', specification.content);
+      await upsertProductContent(
+        {
+          content: specification.content,
+          productId: _id,
+          authorId,
+        },
+        unchainedAPI,
+      );
+    }
+  }
+
+  if (variations || media) {
+    if (!(await modules.products.productExists({ productId: _id }))) {
+      throw new Error(`Can't update non-existing product ${_id}`);
+    }
+  }
+
+  if (variations) {
+    logger.debug('replace variations', variations);
+    await upsertVariations(
+      {
+        variations: variations || [],
+        productId: _id,
+        authorId,
+      },
+      unchainedAPI,
+    );
+  }
+
+  if (media) {
+    logger.debug('replace product media', media);
+    await upsertMedia({ media, productId: _id, authorId }, unchainedAPI);
+  }
+
+  return {
+    entity: 'PRODUCT',
+    operation: 'update',
+    _id,
+    success: true,
+  };
+}

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

@@ -0,0 +1,97 @@
+import { Context } from '@unchainedshop/types/api';
+import { File } from '@unchainedshop/types/files';
+import { ProductMedia, ProductMediaText } from '@unchainedshop/types/products.media';
+
+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: 'product-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 upsertProductMedia = async (productMedia: ProductMedia, { modules, userId }: Context) => {
+  try {
+    const productMediaObj = await modules.products.media.create(productMedia, userId);
+    return productMediaObj;
+  } catch (e) {
+    const { _id, ...productMediaData } = productMedia;
+    const productMediaId = _id;
+    return modules.products.media.update(productMediaId, productMediaData);
+  }
+};
+
+export default async function upsertMedia({ media, authorId, productId }, unchainedAPI: Context) {
+  const { modules, userId } = unchainedAPI;
+
+  const productMediaObjects = await Promise.all(
+    media.map(async ({ asset, content, ...mediaData }) => {
+      const file = await upsertAsset(
+        { meta: { ...(asset.meta || {}), productId }, ...asset },
+        unchainedAPI,
+      );
+      if (!file) throw new Error(`Unable to create binary ${asset._id}`);
+      const fileId = file._id;
+      const productMedia = await upsertProductMedia(
+        {
+          authorId,
+          ...mediaData,
+          productId,
+          mediaId: file._id,
+        } as ProductMedia,
+        unchainedAPI,
+      );
+      if (!productMedia) throw new Error(`Unable to create product media object for file ${fileId}`);
+
+      if (content) {
+        await Promise.all(
+          Object.entries(content).map(
+            async ([locale, { authorId: tAuthorId, ...localizedData }]: [string, ProductMediaText]) => {
+              return modules.products.media.texts.upsertLocalizedText(
+                productMedia._id,
+                locale,
+                localizedData,
+                tAuthorId || authorId || userId,
+              );
+            },
+          ),
+        );
+      }
+      return productMedia;
+    }),
+  );
+
+  await modules.products.media.deleteMediaFiles({
+    productId,
+    excludedProductMediaIds: productMediaObjects.map((obj) => obj._id),
+  });
+}

package/src/bulk-importer/handlers/product/upsertProductContent.ts

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

package/src/bulk-importer/handlers/product/upsertVariations.ts

@@ -0,0 +1,77 @@
+import { Context } from '@unchainedshop/types/api';
+import { ProductVariation, ProductVariationText } from '@unchainedshop/types/products.variations';
+
+const upsert = async (productVariation: ProductVariation, unchainedAPI: Context) => {
+  const { modules, userId } = unchainedAPI;
+  try {
+    return modules.products.variations.create(productVariation, userId);
+  } catch (e) {
+    return modules.products.variations.update(productVariation._id, productVariation);
+  }
+};
+
+export default async function upsertVariations(
+  { variations, authorId, productId },
+  unchainedAPI: Context,
+) {
+  const { modules, userId } = unchainedAPI;
+
+  const productVariationObjects = await Promise.all(
+    variations.map(async ({ content, options, ...variationsRest }) => {
+      const variation = await upsert(
+        {
+          authorId,
+          ...variationsRest,
+          options: options.map((option) => option.value),
+          productId,
+        },
+        unchainedAPI,
+      );
+
+      await Promise.all(
+        options.map(async ({ content: optionContent, value: optionValue }) => {
+          await Promise.all(
+            Object.entries(optionContent).map(
+              async ([locale, { authorId: tAuthorId, ...localizedData }]: [
+                string,
+                ProductVariationText,
+              ]) => {
+                return modules.products.variations.texts.upsertLocalizedText(
+                  {
+                    productVariationId: variation._id,
+                    productVariationOptionValue: optionValue,
+                  },
+                  locale,
+                  localizedData,
+                  tAuthorId || authorId || userId,
+                );
+              },
+            ),
+          );
+        }),
+      );
+      await Promise.all(
+        Object.entries(content).map(
+          async ([locale, { authorId: tAuthorId, ...localizedData }]: [
+            string,
+            ProductVariationText,
+          ]) => {
+            return modules.products.variations.texts.upsertLocalizedText(
+              {
+                productVariationId: variation._id,
+              },
+              locale,
+              localizedData,
+              tAuthorId || authorId || userId,
+            );
+          },
+        ),
+      );
+      return variation;
+    }),
+  );
+  await modules.products.variations.deleteVariations({
+    productId,
+    excludedProductVariationIds: productVariationObjects.map((obj) => obj._id),
+  });
+}

package/src/context/index.ts

@@ -0,0 +1,2 @@
+export { default as withAccessToken } from './withAccessToken';
+export { default as setAccessToken } from './setAccessToken';

package/src/context/setAccessToken.ts

@@ -0,0 +1,15 @@
+import { Context } from '@unchainedshop/types/api';
+
+export default async (unchainedAPI: Context, username: string, secret: string) => {
+  await unchainedAPI.modules.users.updateUser(
+    { username },
+    {
+      $set: {
+        'services.token': {
+          secret,
+        },
+      },
+    },
+    {},
+  );
+};

package/src/context/withAccessToken.ts

@@ -0,0 +1,34 @@
+import { createLogger } from '@unchainedshop/logger';
+
+const logger = createLogger('unchained:platform');
+
+const contextIdentity = (params) => params;
+
+export default (fn = contextIdentity) => {
+  return async (params, unchainedContextFn) => {
+    const unchainedContext = await unchainedContextFn(params);
+    const newContext = {
+      userId: unchainedContext.userId,
+      user: unchainedContext.user,
+    };
+    if (!unchainedContext.userId && params.req.headers.authorization) {
+      const [type, userToken] = params.req.headers.authorization.split(' ');
+      if (type === 'Bearer' && userToken) {
+        const [username, secret] = userToken.split(':');
+        const user = await unchainedContext.modules.users.findUser({
+          username,
+        });
+        if (secret && user?.services.token?.secret === secret) {
+          newContext.userId = user._id;
+          newContext.user = user;
+        } else {
+          logger.warn('Token login failed');
+        }
+      }
+    }
+    return fn({
+      ...unchainedContext,
+      ...newContext,
+    });
+  };
+};

package/src/migrations/createMigrationRunner.js

@@ -0,0 +1,61 @@
+class MigrationError extends Error {
+  constructor(migrationId = null, ...params) {
+    // Pass remaining arguments (including vendor specific ones) to parent constructor
+    super(...params);
+
+    // Maintains proper stack trace for where our error was thrown (only available on V8)
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, MigrationError);
+    }
+
+    this.name = 'MigrationError';
+    this.migrationId = migrationId;
+    this.date = new Date();
+  }
+}
+
+export const createMigrationRunner = ({
+  currentId,
+  logger = console,
+  migrationRepository,
+  onMigrationComplete,
+  unchainedAPI,
+}) => ({
+  operationFactory(action) {
+    const migrationContext = { logger, unchainedAPI };
+
+    return (migration) => async () => {
+      try {
+        await migration[action](migrationContext);
+        await onMigrationComplete(migration.id, action);
+        return migration.id;
+      } catch (e) {
+        throw new MigrationError(migration.id, e.message);
+      }
+    };
+  },
+  isIdAfterCurrentId({ id }) {
+    return id > currentId;
+  },
+  migrateToLatest() {
+    return migrationRepository
+      .allMigrations()
+      .filter(this.isIdAfterCurrentId)
+      .map(this.operationFactory('up'));
+  },
+  async run() {
+    try {
+      const migrations = this.migrateToLatest();
+
+      const mostRecentId = await migrations.reduce(
+        (idPromise, migration) => Promise.resolve(idPromise).then(migration),
+        currentId,
+      );
+
+      return [mostRecentId, migrations.length];
+    } catch (e) {
+      logger.error(e.name, e);
+      return [e.migrationId, null];
+    }
+  },
+});