@unchainedshop/core 4.3.6 → 4.5.0

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

@@ -1,76 +0,0 @@
-import { z } from 'zod';
-import { AssortmentProduct } from '@unchainedshop/core-assortments';
-import convertTagsToLowerCase from '../utils/convertTagsToLowerCase.js';
-import { Modules } from '../../../modules.js';
-
-export const AssortmentProductSchema = z.object({
-  _id: z.string().optional(),
-  productId: z.string(),
-  tags: z.array(z.string()).optional(),
-  sortKey: z.number().optional(),
-  meta: z.record(z.any(), z.any()).optional(),
-});
-
-const upsert = async (
-  assortmentProduct: {
-    _id?: string;
-    productId: string;
-    tags: string[];
-    assortmentId: string;
-    sortKey: number;
-  },
-  unchainedAPI: { modules: Modules },
-) => {
-  const { modules } = unchainedAPI;
-  if (
-    !(await modules.products.productExists({
-      productId: assortmentProduct.productId,
-    }))
-  ) {
-    throw new Error(`Can't link non-existing product ${assortmentProduct.productId}`);
-  }
-  try {
-    const newAssortmentProduct = (await modules.assortments.products.create(assortmentProduct, {
-      skipInvalidation: true,
-    })) as AssortmentProduct;
-    return newAssortmentProduct;
-  } catch {
-    return (await modules.assortments.products.update(assortmentProduct._id!, assortmentProduct, {
-      skipInvalidation: true,
-    })) as AssortmentProduct;
-  }
-};
-
-export default async (
-  {
-    products,
-    assortmentId,
-  }: { products: z.infer<typeof AssortmentProductSchema>[]; assortmentId: string },
-  unchainedAPI: { modules: Modules },
-) => {
-  const { modules } = unchainedAPI;
-  const assortmentProductIds = await Promise.all(
-    products.map(async ({ tags: tagsMixedCase, sortKey, ...rest }, forcedSortKey) => {
-      const tags = tagsMixedCase ? convertTagsToLowerCase(tagsMixedCase)! : [];
-
-      const assortmentProduct = await upsert(
-        {
-          ...rest,
-          tags,
-          sortKey: sortKey ?? forcedSortKey,
-          assortmentId,
-        },
-        unchainedAPI,
-      );
-      return assortmentProduct._id;
-    }),
-  );
-
-  await modules.assortments.products.deleteMany(
-    {
-      _id: { $nin: assortmentProductIds },
-      assortmentId,
-    },
-    { skipInvalidation: true },
-  );
-};

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

@@ -1,76 +0,0 @@
-import { z } from 'zod';
-import { Services } from '../../../services/index.js';
-import { Modules } from '../../../modules.js';
-import upsertAsset, { AssetSchema } from '../../upsertAsset.js';
-import { AssortmentMediaType } from '@unchainedshop/core-assortments';
-
-export const MediaSchema = z.object({
-  _id: z.string().optional(),
-  asset: AssetSchema,
-  content: z
-    .record(
-      z.string(), // locale
-      z.object({
-        title: z.string().optional(),
-        subtitle: z.string().optional(),
-      }),
-    )
-    .optional(),
-  tags: z.array(z.string()).optional(),
-  sortKey: z.number().optional(),
-});
-
-const upsertMediaObject = async (media, unchainedAPI: { modules: Modules; services: Services }) => {
-  const { modules } = unchainedAPI;
-  try {
-    const assortmentMedia = (await modules.assortments.media.create(media)) as AssortmentMediaType;
-    return assortmentMedia;
-  } catch {
-    const { _id, ...mediaData } = media;
-    return (await modules.assortments.media.update(_id, mediaData)) as AssortmentMediaType;
-  }
-};
-
-export default async (
-  { media, assortmentId }: { media: z.infer<typeof MediaSchema>[]; assortmentId: string },
-  unchainedAPI: { modules: Modules; services: Services },
-) => {
-  const { modules } = unchainedAPI;
-  const mediaObjects = await Promise.all(
-    media.map(async ({ asset, content, ...mediaData }) => {
-      const file = await upsertAsset(
-        'assortment-media',
-        { meta: { ...(asset.meta || {}), assortmentId }, ...asset },
-        unchainedAPI,
-      );
-      if (!file) throw new Error(`Unable to create binary ${asset._id}`);
-
-      const mediaObject = await upsertMediaObject(
-        {
-          ...mediaData,
-          assortmentId,
-          mediaId: file._id,
-        },
-        unchainedAPI,
-      );
-
-      if (!mediaObject) throw new Error(`Unable to create media object ${mediaData._id}`);
-
-      if (content) {
-        await modules.assortments.media.texts.updateMediaTexts(
-          mediaObject._id,
-          Object.entries(content).map(([locale, localizedData]: [string, any]) => ({
-            locale,
-            ...localizedData,
-          })),
-        );
-      }
-      return mediaObject;
-    }),
-  );
-
-  await modules.assortments.media.deleteMediaFiles({
-    assortmentId,
-    excludedAssortmentMediaIds: mediaObjects.map((obj) => obj._id),
-  });
-};

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

@@ -1,104 +0,0 @@
-import { z } from 'zod';
-import { Modules } from '../../../modules.js';
-
-export const LocalizedContentSchema = z.record(
-  z.string(), // locale
-  z.object({
-    title: z.string().optional(),
-    subtitle: z.string().optional(),
-  }),
-);
-
-export const FilterCreatePayloadSchema = z.object({
-  _id: z.string(),
-  specification: z.object({
-    type: z.string(),
-    key: z.string(),
-    isActive: z.boolean().optional(),
-    options: z
-      .array(
-        z.object({
-          value: z.string(),
-          content: LocalizedContentSchema.optional(),
-        }),
-      )
-      .optional(),
-    meta: z.record(z.any(), z.any()).optional(),
-    content: LocalizedContentSchema,
-  }),
-});
-
-export default async function createFilter(
-  payload: any,
-  { logger, createShouldUpsertIfIDExists },
-  unchainedAPI: { modules: Modules },
-) {
-  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);
-  try {
-    await unchainedAPI.modules.filters.create({
-      ...filterData,
-      _id,
-      options: options?.map((option) => option.value) || [],
-    });
-  } catch (e) {
-    if (!createShouldUpsertIfIDExists) throw e;
-
-    logger.debug('entity already exists, falling back to update', specification);
-    await modules.filters.update(_id, {
-      ...filterData,
-      options: options?.map((option) => option.value) || [],
-    });
-  }
-
-  if (!(await modules.filters.filterExists({ filterId: _id }))) {
-    throw new Error(`Can't upsert filter ${_id}`);
-  }
-
-  if (content) {
-    logger.debug('create localized content for filter', content);
-    await modules.filters.texts.updateTexts(
-      { filterId: _id },
-      Object.entries(content).map(([locale, localizedData]: [string, any]) => {
-        return {
-          locale,
-          ...localizedData,
-        };
-      }),
-    );
-  }
-
-  if (options) {
-    logger.debug('create localized content for filter options', content);
-    await Promise.all(
-      options.map(async ({ content: optionContent, value: optionValue }) => {
-        if (optionContent) {
-          await modules.filters.texts.updateTexts(
-            { filterId: _id, filterOptionValue: optionValue },
-            Object.entries(optionContent).map(([locale, localizedData]: [string, any]) => {
-              return {
-                locale,
-                ...localizedData,
-              };
-            }),
-          );
-        }
-      }),
-    );
-  }
-
-  return {
-    entity: 'FILTER',
-    operation: 'create',
-    _id,
-    success: true,
-  };
-}

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

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

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

@@ -1,25 +0,0 @@
-import { z } from 'zod';
-import { Modules } from '../../../modules.js';
-
-export const FilterRemovePayloadSchema = z.object({
-  _id: z.string(),
-});
-
-export default async function removeFilter(
-  payload: z.infer<typeof FilterRemovePayloadSchema>,
-  { logger },
-  unchainedAPI: { modules: Modules },
-) {
-  const { modules } = unchainedAPI;
-  const { _id } = payload;
-  logger.debug('remove filter');
-  await modules.assortments.filters.deleteMany({ filterId: _id });
-  await modules.filters.delete(_id);
-
-  return {
-    entity: 'FILTER',
-    operation: 'remove',
-    _id,
-    success: true,
-  };
-}

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

@@ -1,94 +0,0 @@
-import { z } from 'zod';
-import createFilter from './create.js';
-import { Modules } from '../../../modules.js';
-
-export const LocalizedContentSchema = z.record(
-  z.string(), // locale
-  z.object({
-    title: z.string().optional(),
-    subtitle: z.string().optional(),
-  }),
-);
-export const FilterUpdatePayloadSchema = z.object({
-  _id: z.string(),
-  specification: z.object({
-    type: z.string(),
-    key: z.string(),
-    isActive: z.boolean().optional(),
-    options: z
-      .array(
-        z.object({
-          value: z.string(),
-          content: LocalizedContentSchema.optional(),
-        }),
-      )
-      .optional(),
-    meta: z.record(z.any(), z.any()).optional(),
-    content: LocalizedContentSchema,
-  }),
-});
-
-export default async function updateFilter(
-  payload: any,
-  { logger, updateShouldUpsertIfIDNotExists }: { logger: any; updateShouldUpsertIfIDNotExists: boolean },
-  unchainedAPI: { modules: Modules },
-) {
-  const { modules } = unchainedAPI;
-  const { specification, _id } = payload;
-
-  if (!(await modules.filters.filterExists({ filterId: _id }))) {
-    if (updateShouldUpsertIfIDNotExists) {
-      return createFilter(payload, { logger, createShouldUpsertIfIDExists: false }, unchainedAPI);
-    }
-    throw new Error(`Can't update non-existing filter ${_id}`);
-  }
-
-  const { content, options, ...filterData } = specification;
-
-  if (specification) {
-    logger.debug('update filter object', specification);
-    await modules.filters.update(_id, {
-      ...filterData,
-      options: options?.map((option) => option.value) || [],
-    });
-  }
-
-  if (content) {
-    logger.debug('replace localized content for filter', content);
-    await modules.filters.texts.updateTexts(
-      { filterId: _id },
-      Object.entries(content).map(([locale, localizedData]: [string, any]) => {
-        return {
-          locale,
-          ...localizedData,
-        };
-      }),
-    );
-  }
-
-  if (options) {
-    logger.debug('replace localized content for filter options', content);
-    await Promise.all(
-      options.map(async ({ content: optionContent, value: optionValue }) => {
-        if (optionContent) {
-          await modules.filters.texts.updateTexts(
-            { filterId: _id, filterOptionValue: optionValue },
-            Object.entries(optionContent).map(([locale, localizedData]: [string, any]) => {
-              return {
-                locale,
-                ...localizedData,
-              };
-            }),
-          );
-        }
-      }),
-    );
-  }
-
-  return {
-    entity: 'FILTER',
-    operation: 'update',
-    _id,
-    success: true,
-  };
-}

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

@@ -1,170 +0,0 @@
-import { z } from 'zod';
-import { Modules } from '../../../modules.js';
-import { Services } from '../../../services/index.js';
-import upsertVariations, { ProductVariationSchema } from './upsertVariations.js';
-import upsertMedia from './upsertMedia.js';
-import { MediaSchema } from '../assortment/upsertMedia.js';
-import convertTagsToLowerCase from '../utils/convertTagsToLowerCase.js';
-
-export const ProductCreateSpecificationSchema = z.object({
-  type: z.string(),
-  sequence: z.number(),
-  status: z.string().optional().nullable(), // or null!
-  published: z.string().datetime().optional().nullable(), // or null!
-  tags: z.array(z.string()).optional(),
-  commerce: z
-    .object({
-      pricing: z.array(
-        z.object({
-          amount: z.number(),
-          maxQuantity: z.number().optional(),
-          isTaxable: z.boolean().optional(),
-          isNetPrice: z.boolean().optional(),
-          currencyCode: z.string(),
-          countryCode: z.string(),
-        }),
-      ),
-    })
-    .optional(),
-  warehousing: z
-    .object({
-      sku: z.string().optional(),
-      baseUnit: z.string().optional(),
-    })
-    .optional(),
-  supply: z
-    .object({
-      weightInGram: z.number().optional(),
-      heightInMillimeters: z.number().optional(),
-      lengthInMillimeters: z.number().optional(),
-      widthInMillimeters: z.number().optional(),
-    })
-    .optional(),
-  bundleItems: z
-    .array(
-      z.object({
-        productId: z.string(),
-        quantity: z.number(),
-        configuration: z.array(
-          z.object({
-            key: z.string(),
-            value: z.string(),
-          }),
-        ),
-      }),
-    )
-    .optional(),
-  meta: z.record(z.any(), z.any()).optional(),
-  content: z.record(
-    z.string(), // locale
-    z.object({
-      title: z.string().optional(),
-      subtitle: z.string().optional(),
-      slug: z.string().optional(),
-      description: z.string().optional(),
-      brand: z.string().optional(),
-      vendor: z.string().optional(),
-      labels: z.array(z.string()).optional(),
-    }),
-  ),
-  variationResolvers: z
-    .array(
-      z.object({
-        vector: z.record(z.string(), z.any()),
-        productId: z.string(),
-      }),
-    )
-    .optional(),
-});
-
-export const ProductCreatePayloadSchema = z.object({
-  _id: z.string(),
-  specification: ProductCreateSpecificationSchema,
-  media: z.array(MediaSchema).optional(),
-  variations: z.array(ProductVariationSchema).optional(),
-});
-
-const transformSpecification = (specification: z.infer<typeof ProductCreateSpecificationSchema>) => {
-  const {
-    variationResolvers: assignments,
-    content, // eslint-disable-line
-    supply,
-    warehousing,
-    ...productData
-  } = specification;
-
-  const tags = productData?.tags ? convertTagsToLowerCase(productData.tags!)! : [];
-  const proxy = assignments ? { assignments } : undefined;
-
-  return {
-    ...productData,
-    published: productData.published ? new Date(productData.published) : undefined,
-    tags,
-    warehousing,
-    supply,
-    proxy,
-  };
-};
-
-export default async function createProduct(
-  payload: z.infer<typeof ProductCreatePayloadSchema>,
-  { logger, createShouldUpsertIfIDExists },
-  unchainedAPI: { modules: Modules; services: Services },
-) {
-  const { modules } = unchainedAPI;
-  const { specification, media, variations, _id } = payload;
-
-  const productData = transformSpecification(specification);
-  logger.debug('create product object', productData);
-  try {
-    await modules.products.create({
-      ...productData,
-      _id,
-    });
-  } catch (e) {
-    if (!createShouldUpsertIfIDExists) throw e;
-
-    logger.debug('entity already exists, falling back to update', specification);
-    await modules.products.update(_id, {
-      ...productData,
-    });
-  }
-
-  if (!(await modules.products.productExists({ productId: _id }))) {
-    throw new Error(`Can't create product ${_id}`);
-  }
-
-  if (specification.content) {
-    logger.debug('create localized content for product', specification.content);
-    await modules.products.texts.updateTexts(
-      _id,
-      Object.entries(specification.content).map(([locale, localizedData]: [string, any]) => {
-        return {
-          locale,
-          ...localizedData,
-        };
-      }),
-    );
-  }
-
-  logger.debug('create product variations', variations);
-  await upsertVariations(
-    {
-      variations: variations || [],
-      productId: _id,
-    },
-    unchainedAPI,
-  );
-
-  logger.debug('create product media', media);
-  await upsertMedia({ media: media || [], productId: _id }, unchainedAPI);
-
-  return {
-    entity: 'PRODUCT',
-    operation: 'create',
-    _id,
-    success: true,
-  };
-}
-
-createProduct.payloadSchema = ProductCreatePayloadSchema;

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

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

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

@@ -1,27 +0,0 @@
-import { z } from 'zod';
-import { Modules } from '../../../modules.js';
-import { Services } from '../../../services/index.js';
-
-export const ProductRemovePayloadSchema = z.object({
-  _id: z.string(),
-});
-export default async function removeProduct(
-  payload: z.infer<typeof ProductRemovePayloadSchema>,
-  { logger },
-  unchainedAPI: { modules: Modules; services: Services },
-) {
-  const { services } = unchainedAPI;
-  const { _id } = payload;
-  logger.debug(`remove product ${_id}`);
-
-  await services.products.removeProduct({ productId: _id });
-
-  return {
-    entity: 'PRODUCT',
-    operation: 'remove',
-    _id,
-    success: true,
-  };
-}
-
-removeProduct.payloadSchema = ProductRemovePayloadSchema;